Revision 1:7c424a3e12ea, committed 2014-12-04

Comitter:

miguelcordero191

Date:

Thu Dec 04 14:35:52 2014 +0000

Parent:

0:b444ea725ba7

Child:

2:3d8d52e9751c

Commit message:

First release: write and read process working very well

Changed in this revision

--- a/dds.cpp	Tue Dec 02 02:27:30 2014 +0000
+++ b/dds.cpp	Thu Dec 04 14:35:52 2014 +0000
@@ -1,15 +1,12 @@
 #include "dds.h"
 
-static unsigned char controlRegister[4];
-static unsigned char read_spi_data[6];
-/*
-static unsigned short phase1[2];
-static unsigned short phase2[2];
-static unsigned long long freq1[6];
-static unsigned long long freq2[6];
-*/
+static char controlRegister[4];
+static char read_spi_data[6];
 
-DDS::DDS(SPI *spi_dev, DigitalOut *mreset, DigitalIn *outramp, DigitalOut *spmode, DigitalOut *cs, DigitalOut *ioreset, DigitalInOut *updclk){
+static char* ko_msg = "KO";
+static char* ok_msg = "OK";
+
+DDS::DDS(SPI *spi_dev, DigitalOut *mreset, DigitalOut *outramp, DigitalOut *spmode, DigitalOut *cs, DigitalOut *ioreset, DigitalInOut *updclk){
     
     spi_device      = spi_dev;
     
@@ -23,6 +20,10 @@
     dds_updclk->input();
     *dds_sp_mode = 0;
     *dds_cs = 1;
+    *dds_outramp = 0;
+    
+    cmd_answer = NULL;
+    cmd_answer_len = 0;
     
     spi_device->format(SPI_BITS, SPI_MODE);
     spi_device->frequency(SPI_FREQ);
@@ -31,7 +32,7 @@
     
 }
     
-int DDS::__writeData(unsigned char addr, unsigned char ndata, const unsigned char* data){
+int DDS::__writeData(char addr, char ndata, const char* data){
     
     // I/O reset
     *dds_updclk = 0;
@@ -46,19 +47,20 @@
     printf("\r\nWriting Addr = %d", addr);
     spi_device->write(addr & 0x0F);
     
-    for(unsigned char i = ndata; i > 0; i--)
+    for(char i = 0; i < ndata; i++)
     {
         wait_us(150);
-        spi_device->write(data[i-1]);
+        spi_device->write(data[i]);
     }
        
     *dds_cs = 1;
-
-    for(unsigned char i = ndata; i > 0; i--)
+    
+    for(char i = 0; i < ndata; i++)
     {
-        printf("\r\nData[%d] = %d", i-1, data[i-1]);
+        printf("\r\nData[%d] = 0x%x", i, data[i]);
     }
     
+    
     wait_us(10);
     *dds_updclk = 1;
     wait_us(10);
@@ -69,7 +71,7 @@
 }
 
 
-unsigned char* DDS::__readData(unsigned char addr, unsigned char ndata){
+char* DDS::__readData(char addr, char ndata){
     
     // I/O reset
     *dds_io_reset = 1;
@@ -83,35 +85,36 @@
     printf("\r\nReading Addr = %d", addr);
     spi_device->write((addr & 0x0F) | 0x80);
     
-    for(unsigned char i = ndata; i > 0; i--)
+    for(char i = 0; i < ndata; i++)
     {
         wait_us(150);
-        read_spi_data[i-1] = spi_device->write(0x00);
+        read_spi_data[i] = spi_device->write(0x00);
     }
     
     *dds_cs = 1;
-
-    for(unsigned char i = ndata; i > 0; i--)
+    
+    for(char i = 0; i < ndata; i++)
     {
-        printf("\r\nData[%d] = %d", i-1, read_spi_data[i-1]);
+        printf("\r\nData[%d] = 0x%x", i, read_spi_data[i]);
     } 
     
+    
     wait_us(10);
     
     return read_spi_data;
     }
 
-int DDS::__writeDataAndVerify(unsigned char addr, unsigned char ndata, const unsigned char* wr_spi_data){
+int DDS::__writeDataAndVerify(char addr, char ndata, const char* wr_spi_data){
     
     bool            success;
-    unsigned char*  rd_spi_data;
+    char*  rd_spi_data;
     
     this->__writeData(addr, ndata, wr_spi_data);
     rd_spi_data = this->__readData(addr, ndata);
     
     success = true;
     
-    for(unsigned char i = 0; i < ndata; i++)
+    for(char i = 0; i < ndata; i++)
     {
         
         if (wr_spi_data[i] != rd_spi_data[i])
@@ -127,7 +130,7 @@
     return success;
 }
 
-unsigned char* DDS::__getControlRegister(){
+char* DDS::__getControlRegister(){
     
     bool pll_range = 0;
     bool pll_bypass = 1;
@@ -136,14 +139,14 @@
         pll_bypass = 0;
     }
 
-    if (frequency >= 200.0){
+    if (frequency >= 200){
         pll_range = 1;
     }
        
-    controlRegister[3] = 0x10;
-    controlRegister[2] = pll_range*64 + pll_bypass*32 + (cr_multiplier & 0x1F);
-    controlRegister[1] = (cr_mode & 0x07)*2 + cr_ioupdclk;
-    controlRegister[0] = cr_inv_sinc*64 + cr_osk_en*32 + cr_osk_int*16 + cr_msb_lsb*2 + cr_sdo;
+    controlRegister[0] = 0x10 + cr_qdac_pwdn*4;
+    controlRegister[1] = pll_range*64 + pll_bypass*32 + (cr_multiplier & 0x1F);
+    controlRegister[2] = (cr_mode & 0x07)*2 + cr_ioupdclk;
+    controlRegister[3] = cr_inv_sinc*64 + cr_osk_en*32 + cr_osk_int*16 + cr_msb_lsb*2 + cr_sdo;
     
     return controlRegister;
     
@@ -152,9 +155,9 @@
 int DDS::__writeControlRegister(){
     
     bool            success;
-    unsigned char*  wr_spi_data;
-    unsigned char*  rd_spi_data;
-    unsigned char   addr = 0x07, ndata = 4;
+    char*  wr_spi_data;
+    char*  rd_spi_data;
+    char   addr = 0x07, ndata = 4;
     
     wr_spi_data = this->__getControlRegister();
     
@@ -173,7 +176,7 @@
     
     success = true;
     
-    for(unsigned char i = 0; i < ndata; i++)
+    for(char i = 0; i < ndata; i++)
     {
         if (wr_spi_data[i] != rd_spi_data[i])
         {
@@ -221,18 +224,18 @@
     }
     
     if (cont > 10000){
-        printf("\r\nupd_clk did not found\r\n");
+        printf("\r\nA upd_clk was not found\r\n");
         return 0;
     }
     
-    printf("\r\nupd_clk found ...\r\n");
+    printf("\r\nA upd_clk was found ...\r\n");
     
     return 1;
     }
     
 int DDS::find(){
     /*
-    unsigned char phase[];
+    char phase[];
     
     phase[0] = 0x0A;
     phase[1] = 0x55;
@@ -251,15 +254,16 @@
     //printf("\r\nSetting default parameters in CR ...\r\n");
     
     //Serial mode enabled
-    this->frequency = 200.0;      // Work frequency in MHz
-    this->cr_multiplier = 20;     // Multiplier 4- 20
-    this->cr_mode = 0;            // Single, FSK, Ramped FSK, Chirp, BPSK
-    this->cr_ioupdclk = 0;        // IO Update clock direction: 0 -> input,  1 -> output
-    this->cr_inv_sinc  = 0;        // Sinc inverser filter enable: 0 -> enable
-    this->cr_osk_en = 0;          // Enable AM: 0 -> disabled
-    this->cr_osk_int = 0;         // ext/int output shaped control: 0 -> external
-    this->cr_msb_lsb = 0;         // msb/lsb bit first: 0 -> MSB, 1 -> LSB
-    this->cr_sdo = 1;             // SDO pin active: 0 -> inactive
+    this->frequency = 200.0;        // Work frequency in MHz
+    this->cr_multiplier = 4;        // Multiplier 4- 20
+    this->cr_mode = 0;              // Single, FSK, Ramped FSK, Chirp, BPSK
+    this->cr_qdac_pwdn = 0;         // QDAC power down enabled: 0 -> disable
+    this->cr_ioupdclk = 0;          // IO Update clock direction: 0 -> input,  1 -> output
+    this->cr_inv_sinc  = 0;         // Sinc inverser filter enable: 0 -> enable
+    this->cr_osk_en = 1;            // Enable Amplitude multiplier: 0 -> disabled
+    this->cr_osk_int = 0;           // register/counter output shaped control: 0 -> register, 1 -> counter
+    this->cr_msb_lsb = 0;           // msb/lsb bit first: 0 -> MSB, 1 -> LSB
+    this->cr_sdo = 1;               // SDO pin active: 0 -> inactive
 
     //printf("\r\nSetting in serial mode ...\r\n");
     *dds_sp_mode = 0;
@@ -281,53 +285,328 @@
     
     return true;
 }
+
+char* DDS::rdMode(){
     
-int DDS::setSingleMode(){
-    return 0;
+    char* rd_data;
+    char mode;
+    
+    rd_data = this->__readData(0x07, 4);
+    mode = (rd_data[2] & 0x0E) >> 1;
+    
+    rd_data[0] = mode;
+    
+    return rd_data;
     }
     
-int DDS::setFSKMode(){
-    return 0;
+char* DDS::rdMultiplier(){
+    
+    char* rd_data;
+    char mult;
+    
+    rd_data = this->__readData(0x07, 4);
+    mult = (rd_data[1] & 0x1F);
+    
+    rd_data[0] = mult;
+    rd_data[1] = ((int)clock >> 8) & 0xff; 
+    rd_data[2] = (int)clock & 0xff; 
+    
+    return rd_data;    
+    }
+char* DDS::rdPhase1(){
+
+    char* rd_data;
+    
+    rd_data = this->__readData(0x00, 2);
+    
+    return rd_data;
+    
+    }
+char* DDS::rdPhase2(){
+
+    char* rd_data;
+    
+    rd_data = this->__readData(0x01, 2);
+    
+    return rd_data;
+    }
+char* DDS::rdFrequency1(){
+
+    char* rd_data;
+    
+    rd_data = this->__readData(0x02, 6);
+    
+    return rd_data;
+    
+    }
+char* DDS::rdFrequency2(){
+
+    char* rd_data;
+    
+    rd_data = this->__readData(0x03, 6);
+    
+    return rd_data;
+    }
+char* DDS::rdAmplitudeI(){
+
+    char* rd_data;
+    
+    rd_data = this->__readData(0x08, 2);
+    
+    return rd_data;
+    }
+char* DDS::rdAmplitudeQ(){
+
+    char* rd_data;
+    
+    rd_data = this->__readData(0x09, 2);
+    
+    return rd_data;
     }
     
-int DDS::setBPSKMode(){
-    return 0;
-    }
-    
-int DDS::setMode(unsigned char mode){
+int DDS::wrMode(char mode){
     
     this->cr_mode = mode & 0x07;
     
     return this->__writeControlRegister();
     }
 
-int DDS::setMultiplier(unsigned char multiplier, float clock){
+int DDS::wrMultiplier(char multiplier, float clock){
     
     this->cr_multiplier = multiplier & 0x1F;
     this->frequency = clock;
     
+    printf("\r\n mult = %d, clock = %f", multiplier, clock);
+    printf("\r\n cr_mult = %d", cr_multiplier);
+    
     return this->__writeControlRegister();
     }
         
-int DDS::setPhase1(unsigned char* phase){
+int DDS::wrPhase1(char* phase){
     
     return this->__writeDataAndVerify(0x00, 2, phase);
     
     }
     
-int DDS::setPhase2(unsigned char* phase){
+int DDS::wrPhase2(char* phase){
     
     return this->__writeDataAndVerify(0x01, 2, phase);
     
     }
     
-int DDS::setFrequency1(unsigned char* freq){
+int DDS::wrFrequency1(char* freq){
     
     return this->__writeDataAndVerify(0x02, 6, freq);
     
     }
-int DDS::setFrequency2(unsigned char* freq){
+int DDS::wrFrequency2(char* freq){
     
     return this->__writeDataAndVerify(0x03, 6, freq);
     
+    }
+
+int DDS::wrAmplitudeI(char* amplitude){
+    
+    amplitudeI[0] = amplitude[0];
+    amplitudeI[1] = amplitude[1];
+    
+    return this->__writeDataAndVerify(0x08, 2, amplitude);
+    
+    }
+
+int DDS::wrAmplitudeQ(char* amplitude){
+    
+    amplitudeQ[0] = amplitude[0];
+    amplitudeQ[1] = amplitude[1];
+     
+    return this->__writeDataAndVerify(0x09, 2, amplitude);
+    
+    }
+
+int DDS::enableRF(){
+    
+    this->rf_enabled = true;
+    
+    this->wrAmplitudeI(this->amplitudeI);
+    
+    return this->wrAmplitudeQ(this->amplitudeQ);
+    }
+
+int DDS::disableRF(){
+    
+    this->rf_enabled = false;
+    
+    this->wrAmplitudeI("\x00\x00");
+    
+    return this->wrAmplitudeQ("\x00\x00");
+    }
+       
+int DDS::defaultSettings(){
+    
+    this->wrMultiplier(20, 200.0);
+    this->wrAmplitudeI("\x0F\xC0");                        //0xFC0 produces best SFDR than 0xFFF
+    this->wrAmplitudeQ("\x0F\xC0");                        //0xFC0 produces best SFDR than 0xFFF    
+    this->wrFrequency1("\x00\x00\x00\x00\x00\x00");        // 49.92 <> 0x3f 0xe5 0xc9 0x1d 0x14 0xe3 <> 49.92/clock*(2**48) \x3f\xe5\xc9\x1d\x14\xe3
+    this->wrFrequency2("\x00\x00\x00\x00\x00\x00");
+    this->wrPhase1("\x00\x00");                            //0 grados
+    this->wrPhase2("\x20\x00");                            //180 grados <> 0x20 0x00 <> 180/360*(2**14)
+    return this->wrMode(4);                                //BPSK mode
+    
+    }
+    
+char* DDS::newCommand(unsigned short cmd, char* payload, unsigned long payload_len){
+    
+    bool success = false;    
+    char* tx_msg;
+    unsigned long tx_msg_len;
+    
+    tx_msg = ko_msg;
+    tx_msg_len = 2;
+    
+    printf("cmd = %d, payload_len = %d", cmd, payload_len);
+
+    printf("\r\nPayload = ");
+    for(unsigned long i=0; i< payload_len; i++)
+        printf("0x%x ", payload[i]);
+        
+    switch ( cmd )
+      {
+        case 0x01:
+            success = this->init();
+            break;
+            
+        case 0x02:
+            if (payload_len == 1){
+                if (payload[0] == 0)
+                    success = this->disableRF();
+                else
+                    success = this->enableRF();
+            }
+            break;
+            
+        case 0x10:
+            if (payload_len == 3){
+                unsigned short clock = payload[1]*256 + payload[2];
+                success = this->wrMultiplier(payload[0], (float)clock);
+            }
+            break;
+            
+        case 0x11:
+            if (payload_len == 1){
+                success = this->wrMode(payload[0]);
+            }
+            break;
+            
+        case 0x12:
+            if (payload_len == 6){
+                success = this->wrFrequency1(payload);
+            }
+            break;
+            
+        case 0x13:
+            if (payload_len == 6){
+                success = this->wrFrequency2(payload);
+            }
+            break;
+            
+        case 0x14:
+            if (payload_len == 2){
+                success = this->wrPhase1(payload);
+            }
+            break;
+            
+        case 0x15:
+            if (payload_len == 2){
+                success = this->wrPhase2(payload);
+            }
+            break;
+
+        case 0x16:
+            if (payload_len == 2){
+                success = this->wrAmplitudeI(payload);
+            }
+            break;
+
+        case 0x17:
+            if (payload_len == 2){
+                success = this->wrAmplitudeQ(payload);
+            }
+            break;
+
+        case 0x8002:
+            if (rf_enabled == 1)
+                tx_msg = "\x01";
+            else
+                tx_msg = "\x00";
+                
+            tx_msg_len = 1;
+            
+            break;
+            
+        case 0x8010:
+            tx_msg = this->rdMultiplier();
+            tx_msg_len = 3;
+            break;
+            
+        case 0x8011:
+            tx_msg = this->rdMode();
+            tx_msg_len = 1;
+            break;
+            
+        case 0x8012:
+            tx_msg = this->rdFrequency1();
+            tx_msg_len = 6;
+            break;
+            
+        case 0x8013:
+            tx_msg = this->rdFrequency2();
+            tx_msg_len = 6;
+            break;
+            
+        case 0x8014:
+            tx_msg = this->rdPhase1();
+            tx_msg_len = 2;
+            break;
+            
+        case 0x8015:
+            tx_msg = this->rdPhase2();
+            tx_msg_len = 2;
+            break;
+
+        case 0x8016:
+            tx_msg = this->rdAmplitudeI();
+            tx_msg_len = 2;
+            break;
+
+        case 0x8017:
+            tx_msg = this->rdAmplitudeQ();
+            tx_msg_len = 2;
+            break;
+            
+        default:
+            success = false;
+        
+      }
+    
+    if (success){
+        tx_msg = ok_msg;
+        tx_msg_len = 2;
+        }
+    
+    this->cmd_answer = tx_msg;
+    this->cmd_answer_len = tx_msg_len;
+    
+    return tx_msg;
+}
+
+char* DDS::getCmdAnswer(){
+    
+    return this->cmd_answer;
+    
+    }
+    
+unsigned long DDS::getCmdAnswerLen(){
+    
+    return this->cmd_answer_len;
+    
     }
\ No newline at end of file

--- a/dds.h	Tue Dec 02 02:27:30 2014 +0000
+++ b/dds.h	Thu Dec 04 14:35:52 2014 +0000
@@ -7,8 +7,9 @@
 class DDS{
     private:
         float           frequency;              // Work frequency in MHz
-        unsigned char   cr_multiplier;         // Multiplier 4- 20
-        unsigned char   cr_mode;                // Single, FSK, Ramped FSK, Chirp, BPSK
+        char            cr_multiplier;         // Multiplier 4- 20
+        char            cr_mode;                // Single, FSK, Ramped FSK, Chirp, BPSK
+        bool            cr_qdac_pwdn;           // Q DAC power down enable: 0 -> disable
         bool            cr_ioupdclk;            // IO Update clock enable: 0 -> input
         bool            cr_inv_sinc;            // Inverse sinc filter enable: 0 -> enable
         bool            cr_osk_en;              // Enable AM: 0 -> disabled
@@ -19,35 +20,58 @@
         SPI             *spi_device;
         //DDS I/O
         DigitalOut      *dds_mreset;
-        DigitalIn       *dds_outramp;
+        DigitalOut      *dds_outramp;
         DigitalOut      *dds_sp_mode;
         DigitalOut      *dds_cs;
         DigitalOut      *dds_io_reset;
         DigitalInOut    *dds_updclk;
-
-    
-        int __writeData(unsigned char addr, unsigned char ndata, const unsigned char* data);
-        unsigned char* __readData(unsigned char addr, unsigned char ndata);
-        int __writeDataAndVerify(unsigned char addr, unsigned char ndata, const unsigned char* wr_spi_data);
-        unsigned char* __getControlRegister();
+        
+        char            frequency1[6];
+        char            frequency2[6];
+        char            phase1[2];
+        char            phase2[2];       
+        char            amplitudeI[2];
+        char            amplitudeQ[2];
+        bool            rf_enabled;
+        
+        char*           cmd_answer;
+        unsigned long   cmd_answer_len;
+        
+        int __writeData(char addr, char ndata, const char* data);
+        char* __readData(char addr, char ndata);
+        int __writeDataAndVerify(char addr, char ndata, const char* wr_spi_data);
+        char* __getControlRegister();
         int __writeControlRegister();
-        int setSingleMode();
-        int setFSKMode();
-        int setBPSKMode();
         
     public:
         bool isConfig;
         
-        DDS(SPI *spi_dev, DigitalOut *mreset, DigitalIn *outramp, DigitalOut *spmode, DigitalOut *cs, DigitalOut *ioreset, DigitalInOut *updclk);
+        DDS(SPI *spi_dev, DigitalOut *mreset, DigitalOut *outramp, DigitalOut *spmode, DigitalOut *cs, DigitalOut *ioreset, DigitalInOut *updclk);
         int init();
         int reset();
         int scanIOUpdate();
         int find();
-        int setMode(unsigned char mode);
-        int setMultiplier(unsigned char multiplier, float clock);
-        int setPhase1(unsigned char* phase);
-        int setPhase2(unsigned char* phase);
-        int setFrequency1(unsigned char* freq);
-        int setFrequency2(unsigned char* freq);
+        char* rdMode();
+        char* rdMultiplier();
+        char* rdPhase1();
+        char* rdPhase2();
+        char* rdFrequency1();
+        char* rdFrequency2();
+        char* rdAmplitudeI();
+        char* rdAmplitudeQ();
+        int wrMode(char mode);
+        int wrMultiplier(char multiplier, float clock);
+        int wrPhase1(char* phase);
+        int wrPhase2(char* phase);
+        int wrFrequency1(char* freq);
+        int wrFrequency2(char* freq);
+        int wrAmplitudeI(char* amplitude);
+        int wrAmplitudeQ(char* amplitude);
+        int enableRF();
+        int disableRF();
+        int defaultSettings();
+        char* newCommand(unsigned short cmd, char* payload, unsigned long payload_len);
+        char* getCmdAnswer();
+        unsigned long getCmdAnswerLen();
     
 };
\ No newline at end of file

--- a/ipserver.cpp	Tue Dec 02 02:27:30 2014 +0000
+++ b/ipserver.cpp	Thu Dec 04 14:35:52 2014 +0000
@@ -1,5 +1,25 @@
 #include "ipserver.h"
 
+void printCadena(char* cad, int lenc){
+    
+    printf("\r\n");
+    for (int i=0; i<lenc; i++){
+        
+        printf("cad[%d] = %d\r\n", i, cad[i]);
+        }
+    
+    }
+
+IpData::IpData(char* tx_buffer){
+    
+    this->id = ID_DEV;
+    this->isValidData = false;
+    
+    this->len_tx_data = 0;
+    this->tx_buff = tx_buffer;
+    
+    }
+    
 char* IpData::__findHeader(char* buffer){
     /*
     Find header and get ip data (without header)
@@ -20,49 +40,107 @@
     */
     char* valid_ip_data;
     
+    //printf("\r\nSearching header in %s\r\n", buffer);
+    
     //Finding header
     valid_ip_data = strstr(buffer, HEADER);
     
-    if (valid_ip_data == NULL)
+    if (valid_ip_data == NULL){
+        printf("\r\nHeader was not found\r\n");   
         return NULL;
+    }
+    
+    //printf("\r\nHeader was found %s\r\n", valid_ip_data);
+    
+    //printf("\r\nskipping header ...\r\n");
     
     valid_ip_data += 5;  //skip header
-    
+        
     return valid_ip_data;
     }
+
+char IpData::__getXor( char* data, unsigned long len_data){
     
-int IpData::__verifyData(char* ip_data, unsigned long len_data){
+    char new_xor = 0;
+    
+    for(unsigned long i = 0; i < len_data; i++){
+        new_xor = new_xor xor data[i];
+        }
+    
+    return new_xor;
+    }
+    
+int IpData::__verifyData( char* ip_data, unsigned long len_data){
     
     char new_xor = 0;
     
-    for(unsigned long i = 0; i < len_data; i++)
-    {
-        new_xor = new_xor xor ip_data[i];
+    new_xor = this->__getXor(ip_data, len_data);
+    
+    if (new_xor != 0){
+        printf("\r\nInvalid XOR: %d\r\n", new_xor);
+        return 0;
     }
-    
-    if (new_xor != 0)
-        return 0;
         
+    //printf("\r\nXOR verified successfully\r\n");
+    return 1;
+    }
+
+int IpData::__getParameters(){
     return 1;
     }
     
-int IpData::__getParameters(){
-    return 1;
-    }
+char* IpData::encode(unsigned short cmd, char* payload, unsigned long len_payload){
 
-IpData::IpData(){
+    int head_size= strlen(HEADER);
+    char xor_wr;
+    
+    //Copy header
+    strcpy(tx_buff, HEADER);
+    len_tx_data = len_payload + 5;     //Incluye la longitud de la data + 1B (id_class) + 1B (id_dev) + 2B (cmd) + 1B (xor)
+    len_tx_buffer = len_tx_data + 9;     //Incluye 5 bytes del Header + 4 de la longitud
+    
+    tx_buff[0+head_size] = (len_tx_data >> 24) & 0xff;
+    tx_buff[1+head_size] = (len_tx_data >> 16) & 0xff;
+    tx_buff[2+head_size] = (len_tx_data >> 8) & 0xff; 
+    tx_buff[3+head_size] = len_tx_data & 0xff; 
+    
+    tx_buff[4+head_size] = ID_CLASS;
+    tx_buff[5+head_size] = ID_DEV;
     
-    this->isData = false;
+    tx_buff[6+head_size] = (cmd >> 8) & 0xff; 
+    tx_buff[7+head_size] = cmd & 0xff; 
+    
+    for (unsigned int i=0; i<len_payload; i++)
+        tx_buff[8+head_size+i] = payload[i];
+    
+    xor_wr = this->__getXor(&tx_buff[0+head_size], len_tx_data+4-1);   //Incluir todos los bytes de datos mas los 4B de la longitud menos 1B del xor
+    
+    tx_buff[8+head_size+len_payload] = xor_wr;
+
+    printf("\r\nTx Buffer = ");
+    for(unsigned long i=0; i< len_tx_buffer; i++)
+        printf("0x%x ", tx_buff[i]);
+        
+    return tx_buff;
     
     }
     
-int IpData::setIpData(char* buffer, unsigned long len_buffer){
+    
+int IpData::decode( char* buffer, unsigned long len_buffer){
     
     char* ip_data;
     unsigned long len_data;
     
-    if (len_buffer < 13)
+    this->isValidData = false;
+    
+    printf("\r\nRx Buffer = ");
+    for(unsigned long i=0; i< len_buffer; i++)
+        printf("0x%x ", buffer[i]);
+    
+    if (len_buffer < 13){
+        printf("\r\nLongitud de la data insuficiente\r\n");
         return 0;
+        }
         
     //Finding header and get ip data (without header)
     ip_data = this->__findHeader(buffer);
@@ -70,43 +148,82 @@
     if (ip_data == NULL)
         return 0;
     
-    len_data = ip_data[0]*65536 + ip_data[1]*256 + ip_data[2];
+    len_data = ip_data[0]*65536*256 + ip_data[1]*65536 + ip_data[2]*256 + ip_data[3];
     
-    this->buff = ip_data;
+    //printf("\r\nLen data = %d\r\n", len_data);
+    
+    this->rx_buff = ip_data;
     
-    if (not this->__verifyData(ip_data, len_data)){
-        this->isData = false;
+    //len_data + 4 = longitud de toda la data (incluyendo los 4 bytes del campo len)
+    if (not this->__verifyData(ip_data, len_data+4))
         return 0;
+        
+    //head = ip_data[0:5];
+    this->id_class = ip_data[4];
+    this->id_dev = ip_data[5];
+    this->cmd = ip_data[6]*256 + ip_data[7];
+    this->payload = ip_data + 8;
+    this->len_payload = len_data - 5;       //1B id_class, 1B id_dev, 2B cmd y 1B xor
+    this->xor_rd = ip_data[4+len_data-1];
+    
+    printf("\r\nID_CLASS = 0x%x, ID_DEV = 0x%x, CMD = 0x%x, XOR = 0x%x", id_class, id_dev, cmd, xor_rd);
+    printf("\r\nPAYLOAD[0] = 0x%x, PYLD_LEN = 0x%x\r\n", payload[0], len_payload);
+    
+    if (this->id_class == ID_CLASS){
+        this->isValidData = true;
+    
+        return 1;
         }
     
-    //head = ip_data[0:5];
-    this->id_class = ip_data[3];
-    this->id_dev = ip_data[4];
-    this->cmd = ip_data[5]*256 + ip_data[6];
-    this->payload = ip_data + 7;
-    this->payload_len = len_data - 4;
-    this->isData = true;
+    return 0;
     
-    return 1;
     }
     
 char IpData::getIdClass(){
+    
+    if (not this->isValidData)
+        return 0;
+        
     return this->id_class;
     }
     
 char IpData::getIdDevice(){
+    
+    if (not this->isValidData)
+        return 0;
+        
     return this->id_dev;
     }
     
-char IpData::getIpCmd(){
+unsigned short IpData::getCmd(){
+    
+    if (not this->isValidData)
+        return 0;
+        
     return this->cmd;
     }
     
 unsigned long IpData::getPayloadLen(){
-    return this->payload_len;
+    
+    if (not this->isValidData)
+        return 0;
+        
+    return this->len_payload;
     }
     
 char* IpData::getPayload(){
     
+    if (not this->isValidData)
+        return NULL;
+        
     return this->payload;
+    }
+ 
+char* IpData::getTxData(){
+        
+    return this->tx_buff;
+    }   
+unsigned long IpData::getTxDataLen(){
+        
+    return this->len_tx_buffer;
     }
\ No newline at end of file

--- a/ipserver.h	Tue Dec 02 02:27:30 2014 +0000
+++ b/ipserver.h	Thu Dec 04 14:35:52 2014 +0000
@@ -1,33 +1,76 @@
 #include "mbed.h"
-#define HEADER "$JRO$"
+
+#define HEADER      "$JRO$"
+#define ID_CLASS    2
+#define ID_DEV      1
+
+/*
+IP DATA STRUCTURE
+
+5B      3B      1B          1B          2B      NB          1B
+CAB     LEN     ID_CLASS    ID_DEV      CMD     PAYLOAD     XOR
+
+ID_CLASS: Identifica la clase de dispositivo a programar
+
+    1   ->  CR
+    2   ->  DDS
+    3   ->  JARS
+    4   ->  USRP
+    5   ->  ECHOTEK
+    6   ->  ABS
+    7   ->  CLK_GEN
+
+ID_DEV: Identifica el id del dispositivo a programar
+
+    Desde el 1-255, el 0 es usado como broadcast.
+
+CMD: Identifica el comando enviado que define la operacion a realizar
+
+    1   ->  RESET
+    2   ->  DEV. ENABLE
+    3   ->  CONFIG
+    4   ->  
+    5   ->  
+
+*/
 
 class IpData{
 
     private:
         
-        char* buff;
-        unsigned long buffer_len;
+        char* rx_buff;
+        
         char id_class;
         char id_dev;
         unsigned short cmd;
         char* payload;
-        unsigned long payload_len;
+        unsigned long len_payload;
+        char xor_rd;        
         
-        bool isData;
+        char *tx_buff;
+        unsigned long len_tx_data;
+        unsigned long len_tx_buffer;
+        
+        bool isValidData;
         
         char* __findHeader(char* buffer);
-        int __verifyData(char* ip_data, unsigned long len_data);
+        char __getXor( char* data, unsigned long len_data);
+        int __verifyData( char* ip_data, unsigned long len_data);
         int __getParameters();
         
     public:
         
-        IpData();
-        int setIpData(char* buffer, unsigned long len_buffer);
+        IpData(char* tx_buffer);
+        char id;
+        char* encode( unsigned short cmd, char* payload, unsigned long len_payload);
+        int decode( char* buffer, unsigned long len_buffer);
         char getIdClass();
         char getIdDevice();
-        char getIpCmd();
+        unsigned short getCmd();
         unsigned long getPayloadLen();
         char* getPayload();
+        char* getTxData();
+        unsigned long getTxDataLen();
     
 
 };