1 //******************************************************************
3 // Copyright 2014 Intel Corporation.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
26 using namespace Sensors;
28 void IoTServer::initializePlatform()
30 cout << "Running IoTServer constructor" << endl;
31 m_platformConfig = make_shared<PlatformConfig>(ServiceType::InProc, ModeType::Server, "0.0.0.0",
32 0, OC::QualityOfService::HighQos);
33 OCPlatform::Configure(*m_platformConfig);
36 IoTServer::IoTServer()
40 m_temperatureRepresentation.setValue(TEMPERATURE_RESOURCE_KEY, (float) 0.0f);
41 m_ambientLightRepresentation.setValue(LIGHT_RESOURCE_KEY, 0);
42 m_ledRepresentation.setValue(LED_RESOURCE_KEY, 0);
46 IoTServer::~IoTServer()
48 cout << "Running IoTServer destructor" << endl;
52 void IoTServer::setupResources()
54 EntityHandler cb1 = bind(&IoTServer::temperatureEntityHandler, this, placeholders::_1);
55 createResource(TEMPERATURE_RESOURCE_ENDPOINT, TEMPERATURE_RESOURCE_TYPE, cb1,
56 m_temperatureResource);
57 IoTObserverCb tempObsCb = bind(&IoTServer::temperatureObserverLoop, this);
58 m_temperatureObserverLoop = make_shared<IoTObserver>(tempObsCb);
60 EntityHandler cb2 = bind(&IoTServer::lightEntityHandler, this, placeholders::_1);
61 createResource(LIGHT_RESOURCE_ENDPOINT, LIGHT_RESOURCE_TYPE, cb2, m_ambientLightResource);
62 IoTObserverCb lightObsCb = bind(&IoTServer::lightObserverLoop, this);
63 m_ambientLightObserverLoop = make_shared<IoTObserver>(lightObsCb);
65 EntityHandler cb3 = bind(&IoTServer::LEDEntityHandler, this, placeholders::_1);
66 createResource(LED_RESOURCE_ENDPOINT, LED_RESOURCE_TYPE, cb3, m_ledResource);
69 void IoTServer::createResource(string Uri, string Type, EntityHandler Cb, OCResourceHandle& Handle)
71 string resourceUri = Uri;
72 string resourceType = Type;
73 string resourceInterface = EDISON_RESOURCE_INTERFACE;
74 uint8_t resourceFlag = OC_DISCOVERABLE | OC_OBSERVABLE;
76 OCStackResult result = OCPlatform::registerResource(Handle, resourceUri, resourceType,
77 resourceInterface, Cb, resourceFlag);
79 if (result != OC_STACK_OK)
80 cerr << "Could not create " << Type << " resource" << endl;
82 cout << "Successfully created " << Type << " resource" << endl;
85 void IoTServer::putLEDRepresentation()
88 m_ledRepresentation.getValue(LED_RESOURCE_KEY, state);
91 cout << "Turned off LED" << endl;
93 cout << "Turned on LED" << endl;
95 cerr << "Invalid request value" << endl;
98 OCRepresentation IoTServer::getLEDRepresentation()
100 return m_ledRepresentation;
103 void IoTServer::temperatureObserverLoop()
106 cout << "Temperature Observer Callback" << endl;
107 shared_ptr<OCResourceResponse> resourceResponse(new OCResourceResponse());
108 resourceResponse->setErrorCode(200);
109 resourceResponse->setResourceRepresentation(getTemperatureRepresentation(),
110 EDISON_RESOURCE_INTERFACE);
111 OCStackResult result = OCPlatform::notifyListOfObservers(m_temperatureResource,
112 m_temperatureObservers,
114 if (result == OC_STACK_NO_OBSERVERS)
116 cout << "No more observers..Stopping observer loop..." << endl;
117 m_temperatureObserverLoop->stop();
121 void IoTServer::lightObserverLoop()
124 cout << "Light Observer Callback" << endl;
125 shared_ptr<OCResourceResponse> resourceResponse(new OCResourceResponse());
126 resourceResponse->setErrorCode(200);
127 resourceResponse->setResourceRepresentation(getLightRepresentation(),
128 EDISON_RESOURCE_INTERFACE);
129 OCStackResult result = OCPlatform::notifyListOfObservers(m_ambientLightResource,
130 m_ambientLightObservers,
132 if (result == OC_STACK_NO_OBSERVERS)
134 cout << "No more observers..Stopping observer loop..." << endl;
135 m_ambientLightObserverLoop->stop();
139 OCRepresentation IoTServer::getTemperatureRepresentation()
141 m_temperatureRepresentation.setValue(TEMPERATURE_RESOURCE_KEY, GetTemperatureInC());
142 return m_temperatureRepresentation;
145 OCRepresentation IoTServer::getLightRepresentation()
147 m_ambientLightRepresentation.setValue(LIGHT_RESOURCE_KEY, GetLightLevel());
148 return m_ambientLightRepresentation;
151 OCEntityHandlerResult IoTServer::lightEntityHandler(shared_ptr<OCResourceRequest> Request)
153 OCEntityHandlerResult result = OC_EH_ERROR;
156 string requestType = Request->getRequestType();
157 int requestFlag = Request->getRequestHandlerFlag();
158 if (requestFlag & RequestHandlerFlag::RequestFlag)
160 auto Response = std::make_shared<OC::OCResourceResponse>();
161 Response->setRequestHandle(Request->getRequestHandle());
162 Response->setResourceHandle(Request->getResourceHandle());
163 if (requestType == "GET")
165 cout << "GET request for ambient light reading" << endl;
168 Response->setErrorCode(200);
169 Response->setResponseResult(OC_EH_OK);
170 Response->setResourceRepresentation(getLightRepresentation());
171 if (OCPlatform::sendResponse(Response) == OC_STACK_OK)
179 Response->setResponseResult(OC_EH_ERROR);
180 OCPlatform::sendResponse(Response);
181 cerr << "Unsupported request type" << endl;
185 if (requestFlag & RequestHandlerFlag::ObserverFlag)
187 ObservationInfo observationInfo = Request->getObservationInfo();
188 if (ObserveAction::ObserveRegister == observationInfo.action)
190 cout << "Starting observer for ambient light sensor" << endl;
191 m_ambientLightObservers.push_back(observationInfo.obsId);
192 m_ambientLightObserverLoop->start();
194 else if (ObserveAction::ObserveUnregister == observationInfo.action)
196 m_ambientLightObservers.erase(
197 remove(m_ambientLightObservers.begin(), m_ambientLightObservers.end(),
198 observationInfo.obsId),
199 m_ambientLightObservers.end());
206 OCEntityHandlerResult IoTServer::temperatureEntityHandler(shared_ptr<OCResourceRequest> Request)
208 OCEntityHandlerResult result = OC_EH_ERROR;
211 string requestType = Request->getRequestType();
212 int requestFlag = Request->getRequestHandlerFlag();
213 if (requestFlag & RequestHandlerFlag::RequestFlag)
215 auto Response = std::make_shared<OC::OCResourceResponse>();
216 Response->setRequestHandle(Request->getRequestHandle());
217 Response->setResourceHandle(Request->getResourceHandle());
218 if (requestType == "GET")
220 cout << "GET request for temperature sensor reading" << endl;
223 Response->setErrorCode(200);
224 Response->setResponseResult(OC_EH_OK);
225 Response->setResourceRepresentation(getTemperatureRepresentation());
226 if (OCPlatform::sendResponse(Response) == OC_STACK_OK)
234 Response->setResponseResult(OC_EH_ERROR);
235 OCPlatform::sendResponse(Response);
236 cerr << "Unsupported request type" << endl;
240 if (requestFlag & RequestHandlerFlag::ObserverFlag)
242 ObservationInfo observationInfo = Request->getObservationInfo();
243 if (ObserveAction::ObserveRegister == observationInfo.action)
245 cout << "Starting observer for temperature sensor" << endl;
246 m_temperatureObservers.push_back(observationInfo.obsId);
247 m_temperatureObserverLoop->start();
249 else if (ObserveAction::ObserveUnregister == observationInfo.action)
251 m_temperatureObservers.erase(
252 remove(m_temperatureObservers.begin(), m_temperatureObservers.end(),
253 observationInfo.obsId),
254 m_temperatureObservers.end());
261 OCEntityHandlerResult IoTServer::LEDEntityHandler(shared_ptr<OCResourceRequest> Request)
263 OCEntityHandlerResult result = OC_EH_ERROR;
266 string requestType = Request->getRequestType();
267 int requestFlag = Request->getRequestHandlerFlag();
268 if (requestFlag & RequestHandlerFlag::RequestFlag)
270 auto Response = std::make_shared<OC::OCResourceResponse>();
271 Response->setRequestHandle(Request->getRequestHandle());
272 Response->setResourceHandle(Request->getResourceHandle());
273 if (requestType == "PUT")
275 cout << "PUT request for platform LED" << endl;
276 OCRepresentation requestRep = Request->getResourceRepresentation();
277 if (requestRep.hasAttribute(LED_RESOURCE_KEY))
281 requestRep.getValue<int>(LED_RESOURCE_KEY);
285 Response->setResponseResult(OC_EH_ERROR);
286 OCPlatform::sendResponse(Response);
287 cerr << "Client sent invalid resource value type" << endl;
293 Response->setResponseResult(OC_EH_ERROR);
294 OCPlatform::sendResponse(Response);
295 cerr << "Client sent invalid resource key" << endl;
298 m_ledRepresentation = requestRep;
299 putLEDRepresentation();
302 Response->setErrorCode(200);
303 Response->setResourceRepresentation(getLEDRepresentation());
304 Response->setResponseResult(OC_EH_OK);
305 if (OCPlatform::sendResponse(Response) == OC_STACK_OK)
311 else if (requestType == "GET")
313 cout << "GET request for platform LED" << endl;
316 Response->setErrorCode(200);
317 Response->setResourceRepresentation(getLEDRepresentation());
318 Response->setResponseResult(OC_EH_OK);
319 if (OCPlatform::sendResponse(Response) == OC_STACK_OK)
327 Response->setResponseResult(OC_EH_ERROR);
328 OCPlatform::sendResponse(Response);
329 cerr << "Unsupported request type" << endl;
338 void handle_signal(int signal)
346 sigfillset(&sa.sa_mask);
348 sa.sa_handler = handle_signal;
349 sigaction(SIGINT, &sa, NULL);
350 cout << "Press Ctrl-C to quit...." << endl;