Diff: NSDL/nsdl_support.cpp

Revision:

1:cb681dfa1678

Parent:

0:31292d956e92

Child:

3:3e1ad8ab5071

diff -r 31292d956e92 -r cb681dfa1678 NSDL/nsdl_support.cpp
--- a/NSDL/nsdl_support.cpp	Sun Feb 01 18:24:03 2015 +0000
+++ b/NSDL/nsdl_support.cpp	Mon Feb 02 06:12:30 2015 +0000
@@ -9,7 +9,7 @@
 #ifdef DBG
     #undef DBG
 #endif
-#define DBG  printf
+#define DBG  std::printf
 
 Endpoint nsp;
 UDPSocket server;
@@ -57,7 +57,7 @@
     sn_nsdl_create_resource(resource_structure);
 }
 
-sn_nsdl_ep_parameters_s* nsdl_init_register_endpoint(sn_nsdl_ep_parameters_s *endpoint_structure, uint8_t* name, uint8_t* typename_ptr, uint8_t *lifetime_ptr) {
+sn_nsdl_ep_parameters_s* nsdl_init_register_endpoint(sn_nsdl_ep_parameters_s *endpoint_structure, uint8_t *domain, uint8_t* name, uint8_t* typename_ptr, uint8_t *lifetime_ptr) {
     if (endpoint_structure == NULL) {   
         endpoint_structure = (sn_nsdl_ep_parameters_s*)nsdl_alloc(sizeof(sn_nsdl_ep_parameters_s));
     }
@@ -66,6 +66,8 @@
         memset(endpoint_structure, 0, sizeof(sn_nsdl_ep_parameters_s));
         endpoint_structure->endpoint_name_ptr = name;
         endpoint_structure->endpoint_name_len = strlen((char*)name);
+        endpoint_structure->domain_name_ptr = domain;
+        endpoint_structure->domain_name_len = strlen((char *)domain);
         endpoint_structure->type_ptr = typename_ptr;
         endpoint_structure->type_len =  strlen((char*)typename_ptr);
         endpoint_structure->lifetime_ptr = lifetime_ptr;
@@ -85,29 +87,41 @@
 }
 
 static uint8_t tx_cb(sn_nsdl_capab_e protocol, uint8_t *data_ptr, uint16_t data_len, sn_nsdl_addr_s *address_ptr) {
-    //if (m_logger != NULL) m_logger->log("NSP: sending %d bytes...",data_len);
+    //DBG("NSP: sending %d bytes...\r\n",data_len);
     int sent = server.sendTo(nsp, (char*)data_ptr, data_len);
     return 1;
 }
 
 static uint8_t rx_cb(sn_coap_hdr_s *coap_packet_ptr, sn_nsdl_addr_s *address_ptr) {
     // Rx callback process it...
+    //DBG("NSP: received data. processing...\r\n");
     return 0;
 }
 
 void register_endpoint(bool init) {
     sn_nsdl_ep_parameters_s *endpoint_ptr = NULL;
-    endpoint_ptr = nsdl_init_register_endpoint(endpoint_ptr, (uint8_t*)NSP_address_bytes, ep_type, lifetime_ptr);
-    sn_nsdl_update_registration(endpoint_ptr);
+    endpoint_ptr = nsdl_init_register_endpoint(endpoint_ptr, (uint8_t *)domain_name, (uint8_t*)endpoint_name, ep_type, lifetime_ptr);
+    if (init) {
+        if(sn_nsdl_register_endpoint(endpoint_ptr) != 0)
+            DBG("NSP initial registration failed\r\n");
+        else
+            DBG("NSP initial registration OK\r\n");
+    }
+    else {
+        if(sn_nsdl_register_endpoint(endpoint_ptr) != 0)
+            DBG("NSP re-registration failed\r\n");
+        else
+            DBG("NSP re-registration OK\r\n");
+    }
     nsdl_clean_register_endpoint(&endpoint_ptr);
 }
 
 void registration_update_thread(void const *args) {
-    int count = 0;
-    int registration_time = NSP_RD_UPDATE_PERIOD;      // about 2.5 minutes assuming 4 iterations/second
+    int count = -1;
+    int registration_time = 15;      // about 30 seconds if iteration every 2 seconds
     
     // first we want to wait a bit... let the endpoint crank up...
-    Thread::wait(NSP_RD_UPDATE_PERIOD);   // wait about 150 seconds, then go ahead and start the re-registration interval...  
+    Thread::wait(NSP_RD_UPDATE_PERIOD);   // wait about 30 seconds, then go ahead and start the re-registration interval...  
                 
     // now loop this thread forever sleeping and re-registering at the right iteration.
     while(true) {
@@ -124,23 +138,26 @@
 }
 
 void nsdl_init() {    
-    uint8_t nsp_addr[4];
     sn_nsdl_mem_s memory_cbs;
     
+    // initilize the UDP channel
+    server.init();
+    server.bind(nsp_port);
+    
     /* Initialize libNsdl */
     memset(&memory_cbs,0,sizeof(memory_cbs));
-    memset(nsp_addr,0,sizeof(nsp_addr));
     memory_cbs.sn_nsdl_alloc = &nsdl_alloc;
     memory_cbs.sn_nsdl_free = &nsdl_free;
     if(sn_nsdl_init(&tx_cb, &rx_cb, &memory_cbs) == -1) {
-        DBG("NSP: libNsdl init failed\r\n");
+        DBG("NSP: libNsdl init failed.\r\n");
     }
     else {
-        DBG("NSP: libNsdl init successfu\r\nl");
+        DBG("NSP: libNsdl init successful.\r\n");
     }
 
     /* Set nsp address for library */
-    set_NSP_address(nsp_addr, NSP_COAP_UDP_PORT, SN_NSDL_ADDRESS_TYPE_IPV4);
+    DBG("NSP: libNsdl NSP_ADDRESS: %d.%d.%d.%d port: %d\r\n",NSP_address_bytes[0],NSP_address_bytes[1],NSP_address_bytes[2],NSP_address_bytes[3],nsp_port);
+    set_NSP_address(NSP_address_bytes, nsp_port, SN_NSDL_ADDRESS_TYPE_IPV4);
 }
 
 // NSP event loop - spawn a re-registration thread AFTER we have initially registered and begun event processing...     
@@ -159,10 +176,10 @@
     
     // FOREVER: main loop for event processing  
     while(true) {        
-        //if (m_logger != NULL) m_logger->log("NSP: waiting for data...");
+        //DBG("NSP: waiting for data...\r\n");
         int n = server.receiveFrom(from,nsp_buffer,sizeof(nsp_buffer));
 
-        //if (m_logger != NULL) m_logger->log("NSP: received %d bytes... processing...",n);
+        //DBG("NSP: received %d bytes... processing..\r\n.",n);
         if (n >= 0) sn_nsdl_process_coap((uint8_t*)nsp_buffer,n,&received_packet_address);        
      }
 }
\ No newline at end of file