resource/csdk/connectivity/samples/arduino/casample.cpp

   1 /******************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #include <ctype.h>
  22 #include <errno.h>
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "cacommon.h"
  29 #include "cainterface.h"
  30 #include "Arduino.h"
  31
  32 #ifdef ARDUINOWIFI
  33 #include "WiFi.h"
  34 #elif defined ARDUINOETH
  35 #include "Ethernet.h"
  36 #endif
  37
  38 #include "oic_malloc.h"
  39
  40 #define MAX_BUF_LEN 100 //1024
  41 #define MAX_OPT_LEN 16
  42
  43 static bool g_isLeSelected = false;
  44
  45 static void PrintMenu();
  46 static void Process();
  47 static void Initialize();
  48 static void StartListeningServer();
  49 static void StartDiscoveryServer();
  50 static void FindResource();
  51 static void SendRequest();
  52 static void SendRequestAll();
  53 static void SendResponse(CARemoteEndpoint_t *endpoint, const CAInfo_t* info);
  54 static void AdvertiseResource();
  55 static void SendNotification();
  56 static void SelectNetwork();
  57 static void UnselectNetwork();
  58 static void HandleRequestResponse();
  59
  60 static void RequestHandler(const CARemoteEndpoint_t *object, const CARequestInfo_t *requestInfo);
  61 static void ResponseHandler(const CARemoteEndpoint_t *object, const CAResponseInfo_t *responseInfo);
  62 static void ErrorHandler(const CARemoteEndpoint_t *object, const CAErrorInfo_t* errorInfo);
  63 static void Terminate();
  64
  65 void GetData(char *readInput, size_t bufferLength, size_t *dataLength)
  66 {
  67     if (!readInput || bufferLength == 0 || !dataLength)
  68     {
  69         Serial.println("Invalid buffer");
  70         return;
  71     }
  72
  73     while (!Serial.available())
  74     {
  75         delay(500);
  76     }
  77     int len = 0;
  78     while (Serial.available())
  79     {
  80         delay(100);
  81         char c = Serial.read();
  82         if ('\n' != c && '\r' != c && len < bufferLength - 1)
  83         {
  84             readInput[len++] = c;
  85         }
  86         else
  87         {
  88             break;
  89         }
  90     }
  91
  92     readInput[len] = '\0';
  93     Serial.flush();
  94     Serial.print("PD:");
  95     Serial.println(readInput);
  96     (*dataLength) = len;
  97 }
  98
  99 CATransportType_t GetConnectivityType()
 100 {
 101     char type[2] = {0};
 102     Serial.println("Select network");
 103     Serial.println("IPv4: 0");
 104     Serial.println("EDR: 2");
 105     Serial.println("LE: 3");
 106
 107     size_t typeLen = 0;
 108     GetData(type, sizeof(type), &typeLen);
 109     if (0 >= typeLen)
 110     {
 111         Serial.println("i/p err,default ethernet");
 112         return CA_IPV4;
 113     }
 114     switch (type[0])
 115     {
 116         case '0':
 117             return CA_IPV4;
 118         case '2':
 119             return CA_EDR;
 120         case '3':
 121             return CA_LE;
 122     }
 123     return CA_IPV4;
 124 }
 125
 126 void setup()
 127 {
 128     Serial.begin (115200);
 129
 130     Serial.println("============");
 131     Serial.println("CA SAMPLE");
 132     Serial.println("============");
 133     PrintMenu();
 134 }
 135
 136 void loop()
 137 {
 138     char buffer[5] = {0};
 139     size_t len;
 140     if (Serial.available() > 0)
 141     {
 142         GetData(buffer, sizeof(buffer), &len);
 143         if (0 >= len)
 144         {
 145             Serial.println("i/p err");
 146             return;
 147         }
 148         switch (toupper(buffer[0]))
 149         {
 150             case 'M': // menu
 151                 PrintMenu();
 152                 break;
 153
 154             case 'Q': // quit
 155                 Serial.println("quit");
 156                 return;
 157
 158             case 'I': // Initialize interface
 159                 Initialize();
 160                 break;
 161
 162             case 'S': // start listening server
 163                 StartListeningServer();
 164                 break;
 165
 166             case 'D': // start discovery server
 167                 StartDiscoveryServer();
 168                 break;
 169
 170             case 'F': // find resource
 171                 FindResource();
 172                 break;
 173
 174             case 'R': // send request
 175                 SendRequest();
 176                 break;
 177             case 'E': //send request to all
 178                 SendRequestAll();
 179                 break;
 180             case 'A': // advertise resource
 181                 AdvertiseResource();
 182                 break;
 183
 184             case 'B': // send notification
 185                 SendNotification();
 186                 break;
 187
 188             case 'N': // select network
 189                 SelectNetwork();
 190                 break;
 191
 192             case 'X': // unselect network
 193                 UnselectNetwork();
 194                 break;
 195
 196             case 'H': // handle request response
 197                 HandleRequestResponse();
 198                 break;
 199
 200             case 'T': // handle request response
 201                 Terminate();
 202                 break;
 203
 204             default:
 205                 Serial.println("wrong menu");
 206                 break;
 207         }
 208     }
 209     //1:Add check for startserver before calling below api
 210     if (g_isLeSelected)
 211     {
 212         HandleRequestResponse();
 213     }
 214     delay(1000);
 215 }
 216
 217 void Initialize()
 218 {
 219     if(CAInitialize() != CA_STATUS_OK)
 220     {
 221         Serial.println("Initialize failed");
 222         return;
 223     }
 224     SelectNetwork();
 225     // set handler.
 226     CARegisterHandler(RequestHandler, ResponseHandler, ErrorHandler);
 227 }
 228
 229 void StartListeningServer()
 230 {
 231     Serial.println("listening server");
 232     CAResult_t ret = CAStartListeningServer();
 233     if(ret != CA_STATUS_OK)
 234     {
 235         Serial.print("listening failed: ");
 236         Serial.println(ret);
 237         return;
 238     }
 239 }
 240
 241 void StartDiscoveryServer()
 242 {
 243     Serial.println("discovery server");
 244     CAResult_t ret = CAStartDiscoveryServer();
 245     if(ret != CA_STATUS_OK)
 246     {
 247         Serial.print("discovery failed: ");
 248         Serial.println(ret);
 249         return;
 250     }
 251 }
 252
 253 void FindResource()
 254 {
 255     char buf[MAX_BUF_LEN] = {0};
 256     Serial.println("============");
 257     Serial.println("ex) /a/light");
 258     Serial.println("uri: ");
 259     size_t len = 0;
 260     GetData(buf, sizeof(buf), &len);
 261     if (0 >= len)
 262     {
 263         Serial.println("i/p err");
 264         return;
 265     }
 266     // create token
 267     CAToken_t token = NULL;
 268     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 269
 270     CAResult_t res = CAGenerateToken(&token, tokenLength);
 271     if (res != CA_STATUS_OK || (!token))
 272     {
 273         Serial.println("token error");
 274         return;
 275     }
 276
 277     Serial.print("token:");
 278     Serial.println(token);
 279
 280     res = CAFindResource(buf, token, tokenLength);
 281     if (res != CA_STATUS_OK)
 282     {
 283         Serial.print("find error: ");
 284         Serial.println(res);
 285     }
 286     else
 287     {
 288         Serial.println("success: ");
 289         Serial.println(buf);
 290     }
 291     CADestroyToken(token);
 292 }
 293
 294 void SendRequest()
 295 {
 296     char buf[MAX_BUF_LEN] = {0};
 297     CATransportType_t selectedNetwork;
 298     selectedNetwork = GetConnectivityType();
 299
 300     Serial.println("============");
 301     Serial.println("10.11.12.13:4545/res_uri (for IP)");
 302     Serial.println("10:11:12:13:45:45/res_uri (for BT)");
 303     Serial.println("uri: ");
 304
 305     size_t len = 0;
 306     GetData(buf, sizeof(buf), &len);
 307     if (0 >= len)
 308     {
 309         Serial.println("i/p err");
 310         return;
 311     }
 312
 313     // create remote endpoint
 314     CARemoteEndpoint_t *endpoint = NULL;
 315     CAResult_t res = CACreateRemoteEndpoint(buf,selectedNetwork,&endpoint);
 316     if (res != CA_STATUS_OK)
 317     {
 318         Serial.println("Out of memory");
 319         CADestroyRemoteEndpoint(endpoint);
 320         return;
 321     }
 322
 323     memset(buf, 0, sizeof(buf));
 324
 325     Serial.println("\n=============================================\n");
 326     Serial.println("0:CON, 1:NON\n");
 327     Serial.println("select message type : ");
 328     GetData(buf, sizeof(buf), &len);
 329     CAMessageType_t msgType = CA_MSG_CONFIRM;
 330
 331     if (0 >= len)
 332     {
 333         Serial.println("i/p err,default: 0");
 334     }
 335     else if(buf[0] == '1')
 336     {
 337         msgType = CA_MSG_NONCONFIRM;
 338     }
 339
 340     // create token
 341     CAToken_t token = NULL;
 342     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 343
 344     res = CAGenerateToken(&token, tokenLength);
 345     if (res != CA_STATUS_OK || (!token))
 346     {
 347         Serial.println("token error");
 348         return;
 349     }
 350
 351     Serial.println(token);
 352     CAInfo_t requestData = {CA_MSG_RESET};
 353     requestData.token = token;
 354     requestData.tokenLength = tokenLength;
 355     requestData.payload = (CAPayload_t)"Json Payload";
 356
 357     requestData.type = msgType;
 358
 359     CARequestInfo_t requestInfo = {CA_GET, {CA_MSG_RESET}};
 360     requestInfo.method = CA_GET;
 361     requestInfo.info = requestData;
 362
 363     // send request
 364     CASendRequest(endpoint, &requestInfo);
 365     if (NULL != token)
 366     {
 367         CADestroyToken(token);
 368     }
 369
 370     // destroy remote endpoint
 371     if (endpoint != NULL)
 372     {
 373         CADestroyRemoteEndpoint(endpoint);
 374     }
 375
 376     Serial.println("============");
 377 }
 378
 379 void SendRequestAll()
 380 {
 381     char buf[MAX_BUF_LEN] = {0};
 382
 383     CATransportType_t selectedNetwork;
 384     selectedNetwork = GetConnectivityType();
 385
 386     Serial.println("=========");
 387     Serial.println("10.11.12.13:4545/resource_uri ( for IP )");
 388     Serial.println("10:11:12:13:45:45/resource_uri ( for BT )");
 389     Serial.println("uri : ");
 390
 391     size_t len = 0;
 392     GetData(buf, sizeof(buf), &len);
 393     if (0 >= len)
 394     {
 395         Serial.println("i/p err");
 396         return;
 397     }
 398
 399     // create remote endpoint
 400     CARemoteEndpoint_t *endpoint = NULL;
 401     CAResult_t res = CACreateRemoteEndpoint(buf, selectedNetwork, &endpoint);
 402
 403     if (res != CA_STATUS_OK)
 404     {
 405         Serial.println("create remote endpoint error");
 406         CADestroyRemoteEndpoint(endpoint);
 407         return;
 408     }
 409
 410     CAGroupEndpoint_t *group = NULL;
 411     group = (CAGroupEndpoint_t *)OICMalloc(sizeof(CAGroupEndpoint_t));
 412     group->transportType = endpoint->transportType;
 413     group->resourceUri = endpoint->resourceUri;
 414
 415     // create token
 416     CAToken_t token = NULL;
 417     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 418
 419     res = CAGenerateToken(&token, tokenLength);
 420     if (res != CA_STATUS_OK || (!token))
 421     {
 422         Serial.println("token error");
 423         return;
 424     }
 425
 426     Serial.println(token);
 427
 428     CAInfo_t requestData = {CA_MSG_RESET};
 429     requestData.token = token;
 430     requestData.tokenLength = tokenLength;
 431     requestData.payload = "Temp Json Payload";
 432     requestData.type = CA_MSG_NONCONFIRM;
 433
 434     CARequestInfo_t requestInfo = {CA_GET, {CA_MSG_RESET}};
 435     requestInfo.method = CA_GET;
 436     requestInfo.info = requestData;
 437
 438     // send request
 439     // CASendRequest(endpoint, &requestInfo);
 440     CASendRequestToAll(group, &requestInfo);
 441
 442     if (NULL != token)
 443     {
 444         CADestroyToken(token);
 445     }
 446
 447     // destroy remote endpoint
 448     if (endpoint != NULL)
 449     {
 450         CADestroyRemoteEndpoint(endpoint);
 451     }
 452
 453     OICFree(group);
 454     Serial.println("==========");
 455 }
 456
 457 void AdvertiseResource()
 458 {
 459     char buf[MAX_BUF_LEN] = {0};
 460
 461     Serial.println("============");
 462     Serial.println("uri: ");
 463
 464     size_t len = 0;
 465     GetData(buf, sizeof(buf), &len);
 466     if (0 >= len)
 467     {
 468         Serial.println("no i/p");
 469         return;
 470     }
 471
 472     int16_t optionNum = 0;
 473     char optionData[MAX_OPT_LEN] = {0};
 474     char optionNumBuf[2] = {0};
 475
 476     Serial.println("Option Num: ");
 477     GetData(optionNumBuf, sizeof(optionNumBuf), &len);
 478     if (0 >= len)
 479     {
 480         Serial.println("no i/p,0 option");
 481     }
 482     else
 483     {
 484         optionNum = atoi(optionNumBuf);
 485         Serial.println(optionNum);
 486     }
 487
 488     CAHeaderOption_t *headerOpt = NULL;
 489     if (optionNum > 0)
 490     {
 491         headerOpt = (CAHeaderOption_t *) OICCalloc(optionNum, sizeof(CAHeaderOption_t));
 492         if (NULL == headerOpt)
 493         {
 494             Serial.println("Out of memory");
 495             return;
 496         }
 497     }
 498
 499     int i;
 500     for (i = 0 ; i < optionNum ; i++)
 501     {
 502         int optionID = 0;
 503         char getOptionID[4];
 504         Serial.println("Opt ID:");
 505         GetData(getOptionID, sizeof(getOptionID), &len);
 506         if (0 >= len)
 507         {
 508             Serial.println("no i/p");
 509             continue;
 510         }
 511         else
 512         {
 513             optionID = atoi(getOptionID);
 514         }
 515
 516         memset(optionData, 0, sizeof(optionData));
 517         Serial.println("Opt Data:");
 518         GetData(optionData, sizeof(optionData), &len);
 519         if (0 >= len)
 520         {
 521             Serial.println("no i/p");
 522             continue;
 523         }
 524
 525         headerOpt[i].optionID = optionID;
 526         memcpy(headerOpt[i].optionData, optionData, strlen(optionData));
 527         Serial.println("ID:");
 528         Serial.println(optionID);
 529         Serial.println("Data:");
 530         Serial.println(optionData);
 531
 532         headerOpt[i].optionLength = (uint16_t)strlen(optionData);
 533     }
 534
 535     Serial.println("============");
 536     // create token
 537     CAToken_t token = NULL;
 538     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 539
 540     CAResult_t res = CAGenerateToken(&token, tokenLength);
 541     if (res != CA_STATUS_OK || (!token))
 542     {
 543         Serial.println("token error");
 544         return;
 545     }
 546
 547     Serial.println("token");
 548     Serial.println(token);
 549
 550     CAAdvertiseResource(buf, token, tokenLength, headerOpt, (uint8_t)optionNum);
 551     OICFree(headerOpt);
 552     CADestroyToken(token);
 553 }
 554
 555 void SendNotification()
 556 {
 557     char buf[MAX_BUF_LEN] = {0};
 558     CATransportType_t selectedNetwork;
 559     selectedNetwork = GetConnectivityType();
 560
 561     Serial.println("============");
 562     Serial.println("10.11.12.13:4545/res_uri (for IP)");
 563     Serial.println("10:11:12:13:45:45/res_uri (for BT)");
 564     Serial.println("uri: ");
 565
 566     size_t len = 0;
 567     GetData(buf, sizeof(buf), &len);
 568     if (0 >= len)
 569     {
 570         Serial.println("i/p err");
 571         return;
 572     }
 573
 574     // create remote endpoint
 575     CARemoteEndpoint_t *endpoint = NULL;
 576     CAResult_t res = CACreateRemoteEndpoint(buf,selectedNetwork,&endpoint);
 577     if (CA_STATUS_OK != res)
 578     {
 579         Serial.println("Out of memory");
 580         CADestroyRemoteEndpoint(endpoint);
 581         return;
 582     }
 583
 584     // create token
 585     CAToken_t token = NULL;
 586     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 587
 588     res = CAGenerateToken(&token, tokenLength);
 589     if (res != CA_STATUS_OK || (!token))
 590     {
 591         Serial.println("token error");
 592         return;
 593     }
 594
 595     CAInfo_t respondData = {CA_MSG_NONCONFIRM};
 596     respondData.token = token;
 597     respondData.tokenLength = tokenLength;
 598     respondData.payload = (CAPayload_t)"Notification Data";
 599
 600     CAResponseInfo_t responseInfo = {CA_BAD_REQ, {CA_MSG_RESET}};
 601     responseInfo.result = CA_SUCCESS;
 602     responseInfo.info = respondData;
 603
 604     // send request
 605     CASendNotification(endpoint, &responseInfo);
 606     // destroy remote endpoint
 607     if (NULL != endpoint)
 608     {
 609         CADestroyRemoteEndpoint(endpoint);
 610     }
 611
 612     CADestroyToken(token);
 613     Serial.println("============");
 614 }
 615
 616 void SelectNetwork()
 617 {
 618     char buf[MAX_BUF_LEN] = {0};
 619
 620     Serial.println("============");
 621     Serial.println("Select network");
 622     Serial.println("IPv4: 0");
 623     Serial.println("EDR: 2");
 624     Serial.println("LE: 3\n");
 625
 626     size_t len = 0;
 627     GetData(buf, sizeof(buf), &len);
 628     int number = buf[0] - '0';
 629     if (0 >= len || number < 0 || number > 3)
 630     {
 631         Serial.println("Wrong i/p. WIFI selected");
 632         number = 1;
 633     }
 634
 635     switch (number)
 636     {
 637         case 0:
 638             {
 639 #ifdef ARDUINOWIFI
 640                 const char ssid[] = "SSID";              // your network SSID (name)
 641                 const char pass[] = "SSID_Password";     // your network password
 642                 int16_t status = WL_IDLE_STATUS;         // the Wifi radio's status
 643
 644                 if (WiFi.status() == WL_NO_SHIELD)
 645                 {
 646                     Serial.println("ERROR:No Shield");
 647                     return;
 648                 }
 649
 650                 while (status != WL_CONNECTED)
 651                 {
 652                     Serial.print("connecting: ");
 653                     Serial.println(ssid);
 654                     // WiFi.begin api is weird. ssid should also be taken as const char *
 655                     // Connect to WPA/WPA2 network:
 656                     status = WiFi.begin((char *)ssid, pass);
 657                 }
 658 #elif defined ARDUINOETH
 659                 // Note: ****Update the MAC address here with your shield's MAC address****
 660                 uint8_t ETHERNET_MAC[] = {0x90, 0xA2, 0xDA, 0x0E, 0xC4, 0x05};
 661                 uint8_t error = Ethernet.begin(ETHERNET_MAC);
 662                 if (error  == 0)
 663                 {
 664                     Serial.print("Failed: ");
 665                     Serial.println(error);
 666                     return;
 667                 }
 668 #endif
 669             }
 670             break;
 671         case 2:
 672             // Nothing TBD here
 673             break;
 674         case 3:
 675             g_isLeSelected = true;
 676             break;
 677     }
 678
 679     CASelectNetwork(CATransportType_t(1<<number));
 680     Serial.println("============");
 681 }
 682
 683 void UnselectNetwork()
 684 {
 685     char buf[MAX_BUF_LEN] = {0};
 686
 687     Serial.println("============");
 688     Serial.println("Unselect network");
 689     Serial.println("IPv4: 0");
 690     Serial.println("EDR: 2");
 691     Serial.println("LE: 3\n");
 692
 693     size_t len = 0;
 694     GetData(buf, sizeof(buf), &len);
 695     int number = buf[0] - '0';
 696     Serial.println(number);
 697     if (0 >= len || number < 0 || number > 3)
 698     {
 699         Serial.println("Wrong i/p. WIFI selected");
 700         number = 1;
 701     }
 702     if (number == 3)
 703     {
 704         g_isLeSelected = false;
 705     }
 706     CAUnSelectNetwork(1 << number);
 707     Serial.println("Terminate");
 708     CATerminate();
 709     Serial.println("============");
 710 }
 711
 712 void PrintMenu()
 713 {
 714
 715     Serial.println("============");
 716     Serial.println("i: Initialize");
 717     Serial.println("s: start listening server");
 718     Serial.println("d: start discovery server");
 719     Serial.println("f: find resource");
 720     Serial.println("r: send request");
 721     Serial.println("e: send request to all");
 722     Serial.println("a: advertise resource");
 723     Serial.println("b: send notification");
 724     Serial.println("n: select network");
 725     Serial.println("x: unselect network");
 726     Serial.println("h: handle request response");
 727     Serial.println("t: terminate");
 728     Serial.println("q: quit");
 729     Serial.println("============");
 730 }
 731
 732 void HandleRequestResponse()
 733 {
 734     CAHandleRequestResponse();
 735 }
 736
 737 void RequestHandler(const CARemoteEndpoint_t *object, const CARequestInfo_t *requestInfo)
 738 {
 739     if (!object)
 740     {
 741         Serial.println("Remote endpoint is NULL!");
 742         return;
 743     }
 744
 745     if (!requestInfo)
 746     {
 747         Serial.println("Request info is NULL!");
 748         return;
 749     }
 750
 751     Serial.println("uri: ");
 752     Serial.println(object->resourceUri);
 753     Serial.println("RAddr: ");
 754     Serial.println(object->addressInfo.IP.ipAddress);
 755     Serial.println("Port: ");
 756     Serial.println(object->addressInfo.IP.port);
 757     Serial.println("data: ");
 758     Serial.println(requestInfo->info.payload);
 759     Serial.println("Type: ");
 760     Serial.println(requestInfo->info.type);
 761
 762     if (requestInfo->info.options)
 763     {
 764         uint32_t len = requestInfo->info.numOptions;
 765         uint32_t i;
 766         for (i = 0; i < len; i++)
 767         {
 768             Serial.println("Option:");
 769             Serial.println(i+1);
 770             Serial.println("ID:");
 771             Serial.println(requestInfo->info.options[i].optionID);
 772             Serial.println("Data:");
 773             Serial.println((char*)requestInfo->info.options[i].optionData);
 774         }
 775     }
 776     Serial.println("send response");
 777     SendResponse((CARemoteEndpoint_t *)object, (requestInfo != NULL) ? &requestInfo->info : NULL);
 778 }
 779
 780 void ResponseHandler(const CARemoteEndpoint_t *object, const CAResponseInfo_t *responseInfo)
 781 {
 782     if (object && object->resourceUri)
 783     {
 784         Serial.print("uri: ");
 785         Serial.println(object->resourceUri);
 786     }
 787
 788     if (responseInfo)
 789     {
 790         Serial.print("data: ");
 791         Serial.println(responseInfo->info.payload);
 792         Serial.print("Type: ");
 793         Serial.println(responseInfo->info.type);
 794         Serial.print("res result=");
 795         Serial.println(responseInfo->result);
 796     }
 797 }
 798
 799 void ErrorHandler(const CARemoteEndpoint_t *rep, const CAErrorInfo_t* errorInfo)
 800 {
 801     printf("+++++++++++++++++++++++++++++++++++ErrorInfo+++++++++++++++++++++++++++++++++++\n");
 802
 803     if(rep && rep->resourceUri  )
 804     {
 805         printf("Error Handler, RemoteEndpoint Info resourceUri : %s\n", rep->resourceUri);
 806     }
 807     else
 808     {
 809         printf("Error Handler, RemoteEndpoint is NULL");
 810     }
 811
 812     if(errorInfo)
 813     {
 814         const CAInfo_t *info = &errorInfo->info;
 815         printf("Error Handler, ErrorInfo :\n");
 816         printf("Error Handler result    : %d\n", errorInfo->result);
 817         printf("Error Handler token     : %s\n", info->token);
 818         printf("Error Handler messageId : %d\n", (uint16_t) info->messageId);
 819         printf("Error Handler type      : %d\n", info->type);
 820         printf("Error Handler payload   : %s\n", info->payload);
 821
 822         if(CA_ADAPTER_NOT_ENABLED == errorInfo->result)
 823         {
 824             printf("CA_ADAPTER_NOT_ENABLED, enable the adapter\n");
 825         }
 826         else if(CA_SEND_FAILED == errorInfo->result)
 827         {
 828             printf("CA_SEND_FAILED, unable to send the message, check parameters\n");
 829         }
 830         else if(CA_MEMORY_ALLOC_FAILED == errorInfo->result)
 831         {
 832             printf("CA_MEMORY_ALLOC_FAILED, insufficient memory\n");
 833         }
 834         else if(CA_SOCKET_OPERATION_FAILED == errorInfo->result)
 835         {
 836             printf("CA_SOCKET_OPERATION_FAILED, socket operation failed\n");
 837         }
 838         else if(CA_STATUS_FAILED == errorInfo->result)
 839         {
 840             printf("CA_STATUS_FAILED, message could not be delivered, internal error\n");
 841         }
 842     }
 843     printf("++++++++++++++++++++++++++++++++End of ErrorInfo++++++++++++++++++++++++++++++++\n");
 844
 845     return;
 846 }
 847
 848 void SendResponse(CARemoteEndpoint_t *endpoint, const CAInfo_t* info)
 849 {
 850     char buf[MAX_BUF_LEN] = {0};
 851
 852     Serial.println("============");
 853     Serial.println("Select Message Type");
 854     Serial.println("CON: 0");
 855     Serial.println("NON: 1");
 856     Serial.println("ACK: 2");
 857     Serial.println("RESET: 3");
 858
 859     size_t len = 0;
 860     int messageType = 0;
 861     while(1)
 862     {
 863         GetData(buf, sizeof(buf), &len);
 864         if(len >= 1)
 865         {
 866             messageType = buf[0] - '0';
 867             if (messageType >= 0 && messageType <= 3)
 868             {
 869                 break;
 870             }
 871         }
 872         Serial.println("Invalid type");
 873     }
 874
 875     int respCode = 0;
 876     if(messageType != 3)
 877     {
 878         Serial.println("============");
 879         Serial.println("Enter Resp Code:");
 880         Serial.println("For Ex: Empty  : 0");
 881         Serial.println("Success: 200");
 882         Serial.println("Created: 201");
 883         Serial.println("Deleted: 202");
 884         Serial.println("BadReq : 400");
 885         Serial.println("BadOpt : 402");
 886         Serial.println("NotFnd : 404");
 887         Serial.println("Internal Srv Err:500");
 888         Serial.println("Timeout: 504");
 889         while(1)
 890         {
 891             GetData(buf, sizeof(buf), &len);
 892             if(len >= 1)
 893             {
 894                 respCode = atoi(buf);
 895                 if (respCode >= 0 && respCode <= 504)
 896                 {
 897                     break;
 898                 }
 899             }
 900             Serial.println("Invalid response");
 901         }
 902     }
 903
 904     CAInfo_t responseData = {CA_MSG_RESET};
 905     responseData.type = static_cast<CAMessageType_t>(messageType);
 906     responseData.messageId = (info != NULL) ? info->messageId : 0;
 907     if(messageType != 3)
 908     {
 909         responseData.token = (info != NULL) ? info->token : NULL;
 910         responseData.tokenLength = (info != NULL) ? info->tokenLength : 0;
 911         responseData.payload = static_cast<CAPayload_t>("response payload");
 912     }
 913     CAResponseInfo_t responseInfo = {CA_BAD_REQ, {CA_MSG_RESET}};
 914     responseInfo.result = static_cast<CAResponseResult_t>(respCode);
 915     responseInfo.info = responseData;
 916     // send request (transportType from remoteEndpoint of request Info)
 917     CAResult_t res = CASendResponse(endpoint, &responseInfo);
 918     if(res != CA_STATUS_OK)
 919     {
 920         Serial.println("Snd Resp error");
 921     }
 922     else
 923     {
 924         Serial.println("Snd Resp success");
 925     }
 926
 927     Serial.println("============");
 928 }
 929
 930 void Terminate()
 931 {
 932     UnselectNetwork();
 933 }
 934