1 /******************************************************************
3 * Copyright 2014 Samsung Electronics All Rights Reserved.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 ******************************************************************/
29 #include "cainterface.h"
34 #elif defined ARDUINOETH
38 #include "oic_malloc.h"
40 #define MAX_BUF_LEN 100 //1024
41 #define MAX_OPT_LEN 16
44 static bool g_isLeSelected = false;
46 static void PrintMenu();
47 static void Process();
48 static void Initialize();
49 static void StartListeningServer();
50 static void StartDiscoveryServer();
51 static void SendRequest();
52 static void SendRequestAll();
53 static void SendResponse(CAEndpoint_t *endpoint, const CAInfo_t* info);
54 static void SendNotification();
55 static void SelectNetwork();
56 static void UnselectNetwork();
57 static void HandleRequestResponse();
58 static void GetNetworkInfo();
60 static void RequestHandler(const CAEndpoint_t *object, const CARequestInfo_t *requestInfo);
61 static void ResponseHandler(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo);
62 static void ErrorHandler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
63 static void Terminate();
65 void GetData(char *readInput, size_t bufferLength, size_t *dataLength)
67 if (!readInput || bufferLength == 0 || !dataLength)
69 Serial.println("Invalid buffer");
73 while (!Serial.available())
78 while (Serial.available())
81 char c = Serial.read();
82 if ('\n' != c && '\r' != c && len < bufferLength - 1)
92 readInput[len] = '\0';
95 Serial.println(readInput);
99 bool ParseData(char *buf, char *url, char *port, char *resourceUri)
101 char *slash = strchr(buf, '/');
107 strcpy(resourceUri, slash);
109 char *dot = strchr(buf, '.');
110 if (dot && dot < slash)
112 char *colon = strchr(buf, ':');
116 strncpy(port, colon, slash - colon);
117 memmove(port, port+1, strlen(port));
119 if (colon && colon < slash)
121 strncpy(url, buf, colon - buf);
126 strncpy(url, buf, slash - buf);
130 CATransportAdapter_t GetConnectivityType()
133 Serial.println("Select network");
134 Serial.println("IP: 0");
135 Serial.println("GATT (BLE): 1");
136 Serial.println("RFCOMM (EDR): 2");
139 GetData(type, sizeof(type), &typeLen);
142 Serial.println("i/p err,default ethernet");
143 return CA_ADAPTER_IP;
148 return CA_ADAPTER_IP;
150 return CA_ADAPTER_GATT_BTLE;
152 return CA_ADAPTER_RFCOMM_BTEDR;
154 return CA_ADAPTER_IP;
159 Serial.begin (115200);
161 Serial.println("============");
162 Serial.println("CA SAMPLE");
163 Serial.println("============");
169 char buffer[5] = {0};
171 if (Serial.available() > 0)
173 GetData(buffer, sizeof(buffer), &len);
176 Serial.println("i/p err");
179 switch (toupper(buffer[0]))
186 Serial.println("quit");
189 case 'I': // Initialize interface
193 case 'S': // start listening server
194 StartListeningServer();
197 case 'D': // start discovery server
198 StartDiscoveryServer();
201 case 'R': // send request
205 case 'E': //send request to all
208 case 'B': // send notification
211 case 'G': // Get network info
215 case 'N': // select network
219 case 'X': // unselect network
223 case 'H': // handle request response
224 HandleRequestResponse();
227 case 'T': // handle request response
232 Serial.println("wrong menu");
236 //1:Add check for startserver before calling below api
239 HandleRequestResponse();
246 if(CAInitialize() != CA_STATUS_OK)
248 Serial.println("Initialize failed");
253 CARegisterHandler(RequestHandler, ResponseHandler, ErrorHandler);
256 void StartListeningServer()
258 Serial.println("listening server");
259 CAResult_t ret = CAStartListeningServer();
260 if(ret != CA_STATUS_OK)
262 Serial.print("listening failed: ");
268 void StartDiscoveryServer()
270 Serial.println("discovery server");
271 CAResult_t ret = CAStartDiscoveryServer();
272 if(ret != CA_STATUS_OK)
274 Serial.print("discovery failed: ");
282 char buf[MAX_BUF_LEN] = {0};
283 char address[MAX_BUF_LEN] = {0};
284 char resourceUri[MAX_BUF_LEN] = {0};
285 char port[PORT_LENGTH] = {0};
286 CATransportAdapter_t selectedNetwork;
287 selectedNetwork = GetConnectivityType();
289 Serial.println("============");
290 Serial.println("10.11.12.13:4545/res_uri (for IP)");
291 Serial.println("10:11:12:13:45:45/res_uri (for BT)");
292 Serial.println("uri: ");
295 GetData(buf, sizeof(buf), &len);
298 Serial.println("i/p err");
302 if (!ParseData(buf, address, port, resourceUri))
304 Serial.println("bad uri");
308 // create remote endpoint
309 CAEndpoint_t *endpoint = NULL;
310 CAResult_t res = CACreateEndpoint(CA_DEFAULT_FLAGS, selectedNetwork, address, atoi(port),
312 if (res != CA_STATUS_OK)
314 Serial.println("Out of memory");
315 CADestroyEndpoint(endpoint);
319 memset(buf, 0, sizeof(buf));
321 Serial.println("\n=============================================\n");
322 Serial.println("0:CON, 1:NON\n");
323 Serial.println("select message type : ");
324 GetData(buf, sizeof(buf), &len);
325 CAMessageType_t msgType = CA_MSG_CONFIRM;
329 Serial.println("i/p err,default: 0");
331 else if(buf[0] == '1')
333 msgType = CA_MSG_NONCONFIRM;
337 CAToken_t token = NULL;
338 uint8_t tokenLength = CA_MAX_TOKEN_LEN;
340 res = CAGenerateToken(&token, tokenLength);
341 if (res != CA_STATUS_OK || (!token))
343 Serial.println("token error");
347 Serial.println(token);
348 CAInfo_t requestData = {CA_MSG_RESET};
349 requestData.token = token;
350 requestData.tokenLength = tokenLength;
351 requestData.payload = (CAPayload_t)"Json Payload";
353 requestData.type = msgType;
354 requestData.resourceUri = (char *)OICMalloc(strlen(resourceUri) + 1);
355 strcpy(requestData.resourceUri, resourceUri);
357 CARequestInfo_t requestInfo = {CA_GET, {CA_MSG_RESET}};
358 requestInfo.method = CA_GET;
359 requestInfo.isMulticast = false;
360 requestInfo.info = requestData;
361 requestInfo.isMulticast = false;
364 CASendRequest(endpoint, &requestInfo);
367 CADestroyToken(token);
370 // destroy remote endpoint
371 if (endpoint != NULL)
373 CADestroyEndpoint(endpoint);
376 Serial.println("============");
379 void SendRequestAll()
381 char buf[MAX_BUF_LEN] = {0};
382 char address[MAX_BUF_LEN] = {0};
383 char resourceUri[MAX_BUF_LEN] = {0};
384 char port[PORT_LENGTH] = {0};
386 CATransportAdapter_t selectedNetwork;
387 selectedNetwork = GetConnectivityType();
389 Serial.println("\n=============================================\n");
390 Serial.println("ex) /a/light\n");
391 Serial.println("resource uri : ");
394 GetData(buf, sizeof(buf), &len);
397 Serial.println("i/p err");
401 if (!ParseData(buf, address, port, resourceUri))
403 Serial.println("bad uri");
407 // create remote endpoint
408 CAEndpoint_t *endpoint = NULL;
409 CAResult_t res = CACreateEndpoint(CA_DEFAULT_FLAGS, selectedNetwork, address, atoi(port),
412 if (res != CA_STATUS_OK)
414 Serial.println("create remote endpoint error");
415 CADestroyEndpoint(endpoint);
420 CAToken_t token = NULL;
421 uint8_t tokenLength = CA_MAX_TOKEN_LEN;
423 res = CAGenerateToken(&token, tokenLength);
424 if (res != CA_STATUS_OK || (!token))
426 Serial.println("token error");
430 Serial.println(token);
432 CAInfo_t requestData = {CA_MSG_RESET};
433 requestData.token = token;
434 requestData.tokenLength = tokenLength;
435 requestData.payload = (CAPayload_t)"Temp Json Payload";
436 requestData.type = CA_MSG_NONCONFIRM;
437 requestData.resourceUri = (char *)OICMalloc(strlen(resourceUri) + 1);
438 strcpy(requestData.resourceUri, resourceUri);
440 CARequestInfo_t requestInfo = {CA_GET, {CA_MSG_RESET}};
441 requestInfo.method = CA_GET;
442 requestInfo.isMulticast = true;
443 requestInfo.info = requestData;
446 CASendRequest(endpoint, &requestInfo);
450 CADestroyToken(token);
453 // destroy remote endpoint
454 if (endpoint != NULL)
456 CADestroyEndpoint(endpoint);
459 Serial.println("==========");
462 void SendNotification()
464 char buf[MAX_BUF_LEN] = {0};
465 char address[MAX_BUF_LEN] = {0};
466 char resourceUri[MAX_BUF_LEN] = {0};
467 char port[PORT_LENGTH] = {0};
468 CATransportAdapter_t selectedNetwork;
469 selectedNetwork = GetConnectivityType();
471 Serial.println("============");
472 Serial.println("10.11.12.13:4545/res_uri (for IP)");
473 Serial.println("10:11:12:13:45:45/res_uri (for BT)");
474 Serial.println("uri: ");
477 GetData(buf, sizeof(buf), &len);
480 Serial.println("i/p err");
484 if (!ParseData(buf, address, port, resourceUri))
486 Serial.println("bad uri");
490 // create remote endpoint
491 CAEndpoint_t *endpoint = NULL;
492 CAResult_t res = CACreateEndpoint(CA_DEFAULT_FLAGS, selectedNetwork, address, atoi(port),
494 if (CA_STATUS_OK != res)
496 Serial.println("Out of memory");
497 CADestroyEndpoint(endpoint);
502 CAToken_t token = NULL;
503 uint8_t tokenLength = CA_MAX_TOKEN_LEN;
505 res = CAGenerateToken(&token, tokenLength);
506 if (res != CA_STATUS_OK || (!token))
508 Serial.println("token error");
512 CAInfo_t respondData = {CA_MSG_NONCONFIRM};
513 respondData.token = token;
514 respondData.tokenLength = tokenLength;
515 respondData.payload = (CAPayload_t)"Notification Data";
516 respondData.resourceUri = (char *)OICMalloc(strlen(resourceUri) + 1);
517 strcpy(respondData.resourceUri, resourceUri);
519 CAResponseInfo_t responseInfo = {CA_BAD_REQ, {CA_MSG_RESET}};
520 responseInfo.result = CA_CONTENT;
521 responseInfo.info = respondData;
524 CASendNotification(endpoint, &responseInfo);
525 // destroy remote endpoint
526 if (NULL != endpoint)
528 CADestroyEndpoint(endpoint);
531 CADestroyToken(token);
532 Serial.println("============");
537 char buf[MAX_BUF_LEN] = {0};
539 Serial.println("============");
540 Serial.println("Select network");
541 Serial.println("IP: 0");
542 Serial.println("LE: 1");
543 Serial.println("EDR: 2\n");
546 GetData(buf, sizeof(buf), &len);
547 int number = buf[0] - '0';
548 if (0 >= len || number < 0 || number > 3)
550 Serial.println("Wrong i/p. WIFI selected");
559 const char ssid[] = "SSID"; // your network SSID (name)
560 const char pass[] = "SSID_Password"; // your network password
561 int16_t status = WL_IDLE_STATUS; // the Wifi radio's status
563 if (WiFi.status() == WL_NO_SHIELD)
565 Serial.println("ERROR:No Shield");
569 while (status != WL_CONNECTED)
571 Serial.print("connecting: ");
572 Serial.println(ssid);
573 // WiFi.begin api is weird. ssid should also be taken as const char *
574 // Connect to WPA/WPA2 network:
575 status = WiFi.begin((char *)ssid, pass);
577 #elif defined ARDUINOETH
578 // Note: ****Update the MAC address here with your shield's MAC address****
579 uint8_t ETHERNET_MAC[] = {0x90, 0xA2, 0xDA, 0x0E, 0xC4, 0x05};
580 uint8_t error = Ethernet.begin(ETHERNET_MAC);
583 Serial.print("Failed: ");
584 Serial.println(error);
591 g_isLeSelected = true;
598 CASelectNetwork(CATransportAdapter_t(1<<number));
599 Serial.println("============");
602 void UnselectNetwork()
604 char buf[MAX_BUF_LEN] = {0};
606 Serial.println("============");
607 Serial.println("Unselect network");
608 Serial.println("IPv4: 0");
609 Serial.println("LE: 1");
610 Serial.println("EDR: 2\n");
613 GetData(buf, sizeof(buf), &len);
614 int number = buf[0] - '0';
615 Serial.println(number);
616 if (0 >= len || number < 0 || number > 3)
618 Serial.println("Wrong i/p. WIFI selected");
623 g_isLeSelected = false;
625 CAUnSelectNetwork(1 << number);
626 Serial.println("Terminate");
628 Serial.println("============");
631 void GetNetworkInfo()
633 CAEndpoint_t *tempInfo = NULL;
634 uint32_t tempSize = 0;
635 CAResult_t res = CAGetNetworkInformation(&tempInfo, &tempSize);
636 if (CA_STATUS_OK != res || NULL == tempInfo || 0 >= tempSize)
638 Serial.println("Network not connected");
642 Serial.println("=========");
643 Serial.print("Network info total size is ");
644 Serial.println(tempSize);
646 for (index = 0; index < tempSize; index++)
648 Serial.print("Type: ");
649 Serial.println(tempInfo[index].adapter);
650 if (CA_ADAPTER_IP == tempInfo[index].adapter)
652 Serial.print("Address: ");
653 Serial.println(tempInfo[index].addr);
654 Serial.print("Port: ");
655 Serial.println(tempInfo[index].port);
659 Serial.println("=======");
665 Serial.println("============");
666 Serial.println("i: Initialize");
667 Serial.println("s: start listening server");
668 Serial.println("d: start discovery server");
669 Serial.println("r: send request");
670 Serial.println("e: send request to all");
671 Serial.println("b: send notification");
672 Serial.println("g: get network info");
673 Serial.println("n: select network");
674 Serial.println("x: unselect network");
675 Serial.println("h: handle request response");
676 Serial.println("t: terminate");
677 Serial.println("q: quit");
678 Serial.println("============");
681 void HandleRequestResponse()
683 CAHandleRequestResponse();
686 void RequestHandler(const CAEndpoint_t *object, const CARequestInfo_t *requestInfo)
690 Serial.println("endpoint is NULL!");
696 Serial.println("Request info is NULL!");
700 Serial.print("RAddr: ");
701 Serial.println(object->addr);
702 Serial.print("Port: ");
703 Serial.println(object->port);
704 Serial.print("uri: ");
705 Serial.println(requestInfo->info.resourceUri);
706 Serial.print("data: ");
707 Serial.println((char*)requestInfo->info.payload);
708 Serial.print("Type: ");
709 Serial.println(requestInfo->info.type);
711 if (requestInfo->info.options)
713 uint32_t len = requestInfo->info.numOptions;
715 for (i = 0; i < len; i++)
717 Serial.print("Option: ");
719 Serial.print("ID: ");
720 Serial.println(requestInfo->info.options[i].optionID);
721 Serial.print("Data: ");
722 Serial.println((char*)requestInfo->info.options[i].optionData);
725 Serial.println("send response");
726 SendResponse((CAEndpoint_t *)object, (requestInfo != NULL) ? &requestInfo->info : NULL);
729 void ResponseHandler(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
733 Serial.print("uri: ");
734 Serial.println(object->addr);
739 Serial.print("uri: ");
740 Serial.println(responseInfo->info.resourceUri);
741 Serial.print("data: ");
742 Serial.println((char*)responseInfo->info.payload);
743 Serial.print("Type: ");
744 Serial.println(responseInfo->info.type);
745 Serial.print("res result=");
746 Serial.println(responseInfo->result);
750 void ErrorHandler(const CAEndpoint_t *rep, const CAErrorInfo_t* errorInfo)
752 Serial.println("ErrorInfo");
756 const CAInfo_t *info = &errorInfo->info;
757 Serial.print("result: ");
758 Serial.println(errorInfo->result);
759 Serial.print("token: ");
760 Serial.println(info->token);
761 Serial.print("messageId: ");
762 Serial.println(info->messageId);
763 Serial.print("type: ");
764 Serial.println(info->type);
765 Serial.print("resourceUri: ");
766 Serial.println(info->resourceUri);
767 Serial.print("payload: ");
768 Serial.println((char*)info->payload);
774 void SendResponse(CAEndpoint_t *endpoint, const CAInfo_t* info)
776 char buf[MAX_BUF_LEN] = {0};
778 Serial.println("============");
779 Serial.println("Select Message Type");
780 Serial.println("CON: 0");
781 Serial.println("NON: 1");
782 Serial.println("ACK: 2");
783 Serial.println("RESET: 3");
789 GetData(buf, sizeof(buf), &len);
792 messageType = buf[0] - '0';
793 if (messageType >= 0 && messageType <= 3)
798 Serial.println("Invalid type");
804 Serial.println("============");
805 Serial.println("Enter Resp Code:");
806 Serial.println("For Ex: Empty : 0");
807 Serial.println("Success: 200");
808 Serial.println("Created: 201");
809 Serial.println("Deleted: 202");
810 Serial.println("Valid : 203");
811 Serial.println("Changed: 204");
812 Serial.println("Content: 205");
813 Serial.println("BadReq : 400");
814 Serial.println("BadOpt : 402");
815 Serial.println("NotFnd : 404");
816 Serial.println("Internal Srv Err:500");
817 Serial.println("Timeout: 504");
820 GetData(buf, sizeof(buf), &len);
823 respCode = atoi(buf);
824 if (respCode >= 0 && respCode <= 504)
829 Serial.println("Invalid response");
833 CAInfo_t responseData = {CA_MSG_RESET};
834 responseData.type = static_cast<CAMessageType_t>(messageType);
835 responseData.messageId = (info != NULL) ? info->messageId : 0;
836 responseData.resourceUri = (info != NULL) ? info->resourceUri : 0;
839 responseData.token = (info != NULL) ? info->token : NULL;
840 responseData.tokenLength = (info != NULL) ? info->tokenLength : 0;
841 responseData.payload = reinterpret_cast<CAPayload_t>(const_cast<char*>("response payload"));
843 CAResponseInfo_t responseInfo = {CA_BAD_REQ, {CA_MSG_RESET}};
844 responseInfo.result = static_cast<CAResponseResult_t>(respCode);
845 responseInfo.info = responseData;
846 // send request (transportType from remoteEndpoint of request Info)
847 CAResult_t res = CASendResponse(endpoint, &responseInfo);
848 if(res != CA_STATUS_OK)
850 Serial.println("Snd Resp error");
854 Serial.println("Snd Resp success");
857 Serial.println("============");