CBOR rebase onto master for merge/review
[iotivity.git] / resource / csdk / stack / samples / arduino / SimpleClientServer / ocserver / ocserver.cpp
1 //******************************************************************
2 //
3 // Copyright 2014 Intel Mobile Communications GmbH 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 // Do not remove the include below
22 #include "Arduino.h"
23
24 #include "logger.h"
25 #include "ocstack.h"
26 #include "ocpayload.h"
27 #include <string.h>
28
29 #ifdef ARDUINOWIFI
30 // Arduino WiFi Shield
31 #include <SPI.h>
32 #include <WiFi.h>
33 #include <WiFiUdp.h>
34 #else
35 // Arduino Ethernet Shield
36 #include <EthernetServer.h>
37 #include <Ethernet.h>
38 #include <Dns.h>
39 #include <EthernetClient.h>
40 #include <util.h>
41 #include <EthernetUdp.h>
42 #include <Dhcp.h>
43 #endif
44
45 const char *getResult(OCStackResult result);
46
47 PROGMEM const char TAG[] = "ArduinoServer";
48
49 int gLightUnderObservation = 0;
50 void createLightResource();
51
52 /* Structure to represent a Light resource */
53 typedef struct LIGHTRESOURCE{
54     OCResourceHandle handle;
55     bool state;
56     int power;
57 } LightResource;
58
59 static LightResource Light;
60
61 #ifdef ARDUINOWIFI
62 // Arduino WiFi Shield
63 // Note : Arduino WiFi Shield currently does NOT support multicast and therefore
64 // this server will NOT be listening on 224.0.1.187 multicast address.
65
66 static const char ARDUINO_WIFI_SHIELD_UDP_FW_VER[] = "1.1.0";
67
68 /// WiFi Shield firmware with Intel patches
69 static const char INTEL_WIFI_SHIELD_FW_VER[] = "1.2.0";
70
71 /// WiFi network info and credentials
72 char ssid[] = "mDNSAP";
73 char pass[] = "letmein9";
74
75 int ConnectToNetwork()
76 {
77     char *fwVersion;
78     int status = WL_IDLE_STATUS;
79     // check for the presence of the shield:
80     if (WiFi.status() == WL_NO_SHIELD)
81     {
82         OC_LOG(ERROR, TAG, PCF("WiFi shield not present"));
83         return -1;
84     }
85
86     // Verify that WiFi Shield is running the firmware with all UDP fixes
87     fwVersion = WiFi.firmwareVersion();
88     OC_LOG_V(INFO, TAG, "WiFi Shield Firmware version %s", fwVersion);
89     if ( strncmp(fwVersion, ARDUINO_WIFI_SHIELD_UDP_FW_VER, sizeof(ARDUINO_WIFI_SHIELD_UDP_FW_VER)) !=0 )
90     {
91         OC_LOG(DEBUG, TAG, PCF("!!!!! Upgrade WiFi Shield Firmware version !!!!!!"));
92         return -1;
93     }
94
95     // attempt to connect to Wifi network:
96     while (status != WL_CONNECTED)
97     {
98         OC_LOG_V(INFO, TAG, "Attempting to connect to SSID: %s", ssid);
99         status = WiFi.begin(ssid,pass);
100
101         // wait 10 seconds for connection:
102         delay(10000);
103     }
104     OC_LOG(DEBUG, TAG, PCF("Connected to wifi"));
105
106     IPAddress ip = WiFi.localIP();
107     OC_LOG_V(INFO, TAG, "IP Address:  %d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
108     return 0;
109 }
110 #else
111 // Arduino Ethernet Shield
112 int ConnectToNetwork()
113 {
114     // Note: ****Update the MAC address here with your shield's MAC address****
115     uint8_t ETHERNET_MAC[] = {0x90, 0xA2, 0xDA, 0x0E, 0xC4, 0x05};
116     uint8_t error = Ethernet.begin(ETHERNET_MAC);
117     if (error  == 0)
118     {
119         OC_LOG_V(ERROR, TAG, "error is: %d", error);
120         return -1;
121     }
122
123     IPAddress ip = Ethernet.localIP();
124     OC_LOG_V(INFO, TAG, "IP Address:  %d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
125     return 0;
126 }
127 #endif //ARDUINOWIFI
128
129 // On Arduino Atmel boards with Harvard memory architecture, the stack grows
130 // downwards from the top and the heap grows upwards. This method will print
131 // the distance(in terms of bytes) between those two.
132 // See here for more details :
133 // http://www.atmel.com/webdoc/AVRLibcReferenceManual/malloc_1malloc_intro.html
134 void PrintArduinoMemoryStats()
135 {
136     #ifdef ARDUINO_AVR_MEGA2560
137     //This var is declared in avr-libc/stdlib/malloc.c
138     //It keeps the largest address not allocated for heap
139     extern char *__brkval;
140     //address of tmp gives us the current stack boundry
141     int tmp;
142     OC_LOG_V(INFO, TAG, "Stack: %u         Heap: %u", (unsigned int)&tmp, (unsigned int)__brkval);
143     OC_LOG_V(INFO, TAG, "Unallocated Memory between heap and stack: %u",
144             ((unsigned int)&tmp - (unsigned int)__brkval));
145     #endif
146 }
147
148 // This is the entity handler for the registered resource.
149 // This is invoked by OCStack whenever it recevies a request for this resource.
150 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
151                                         void *callbackParam)
152 {
153     OCEntityHandlerResult ehRet = OC_EH_OK;
154     OCEntityHandlerResponse response = {0};
155     OCRepPayload* payload = OCRepPayloadCreate();
156     if(!payload)
157     {
158         OC_LOG(ERROR, TAG, PCF("Failed to allocate Payload"));
159         return OC_EH_ERROR;
160     }
161
162     if(entityHandlerRequest && (flag & OC_REQUEST_FLAG))
163     {
164         OC_LOG (INFO, TAG, PCF("Flag includes OC_REQUEST_FLAG"));
165
166         if(OC_REST_GET == entityHandlerRequest->method)
167         {
168             OCRepPayloadSetUri(payload, "/a/light");
169             OCRepPayloadSetPropBool(payload, "state", true);
170             OCRepPayloadSetPropInt(payload, "power", 10);
171         }
172         else if(OC_REST_PUT == entityHandlerRequest->method)
173         {
174             //Do something with the 'put' payload
175             OCRepPayloadSetUri(payload, "/a/light");
176             OCRepPayloadSetPropBool(payload, "state", false);
177             OCRepPayloadSetPropInt(payload, "power", 0);
178         }
179
180         if (ehRet == OC_EH_OK)
181         {
182             // Format the response.  Note this requires some info about the request
183             response.requestHandle = entityHandlerRequest->requestHandle;
184             response.resourceHandle = entityHandlerRequest->resource;
185             response.ehResult = ehRet;
186             response.payload = (OCPayload*) payload;
187             response.numSendVendorSpecificHeaderOptions = 0;
188             memset(response.sendVendorSpecificHeaderOptions, 0,
189                     sizeof response.sendVendorSpecificHeaderOptions);
190             memset(response.resourceUri, 0, sizeof response.resourceUri);
191             // Indicate that response is NOT in a persistent buffer
192             response.persistentBufferFlag = 0;
193
194             // Send the response
195             if (OCDoResponse(&response) != OC_STACK_OK)
196             {
197                 OC_LOG(ERROR, TAG, "Error sending response");
198                 ehRet = OC_EH_ERROR;
199             }
200         }
201     }
202     if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
203     {
204         if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
205         {
206             OC_LOG (INFO, TAG, PCF("Received OC_OBSERVE_REGISTER from client"));
207             gLightUnderObservation = 1;
208         }
209         else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
210         {
211             OC_LOG (INFO, TAG, PCF("Received OC_OBSERVE_DEREGISTER from client"));
212         }
213     }
214
215     return ehRet;
216 }
217
218 // This method is used to display 'Observe' functionality of OC Stack.
219 static uint8_t modCounter = 0;
220 void *ChangeLightRepresentation (void *param)
221 {
222     (void)param;
223     OCStackResult result = OC_STACK_ERROR;
224     modCounter += 1;
225     // Matching the timing that the Linux Sample Server App uses for the same functionality.
226     if(modCounter % 10 == 0)
227     {
228         Light.power += 5;
229         if (gLightUnderObservation)
230         {
231             OC_LOG_V(INFO, TAG, " =====> Notifying stack of new power level %d\n", Light.power);
232             result = OCNotifyAllObservers (Light.handle, OC_NA_QOS);
233             if (OC_STACK_NO_OBSERVERS == result)
234             {
235                 gLightUnderObservation = 0;
236             }
237         }
238     }
239     return NULL;
240 }
241
242 //The setup function is called once at startup of the sketch
243 void setup()
244 {
245     // Add your initialization code here
246     // Note : This will initialize Serial port on Arduino at 115200 bauds
247     OC_LOG_INIT();
248     OC_LOG(DEBUG, TAG, PCF("OCServer is starting..."));
249
250     // Connect to Ethernet or WiFi network
251     if (ConnectToNetwork() != 0)
252     {
253         OC_LOG(ERROR, TAG, PCF("Unable to connect to network"));
254         return;
255     }
256
257     // Initialize the OC Stack in Server mode
258     if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
259     {
260         OC_LOG(ERROR, TAG, PCF("OCStack init error"));
261         return;
262     }
263
264     // Declare and create the example resource: Light
265     createLightResource();
266 }
267
268 // The loop function is called in an endless loop
269 void loop()
270 {
271     // This artificial delay is kept here to avoid endless spinning
272     // of Arduino microcontroller. Modify it as per specific application needs.
273     delay(2000);
274
275     // This call displays the amount of free SRAM available on Arduino
276     PrintArduinoMemoryStats();
277
278     // Give CPU cycles to OCStack to perform send/recv and other OCStack stuff
279     if (OCProcess() != OC_STACK_OK)
280     {
281         OC_LOG(ERROR, TAG, PCF("OCStack process error"));
282         return;
283     }
284     ChangeLightRepresentation(NULL);
285 }
286
287 void createLightResource()
288 {
289     Light.state = false;
290     OCStackResult res = OCCreateResource(&Light.handle,
291             "core.light",
292             OC_RSRVD_INTERFACE_DEFAULT,
293             "/a/light",
294             OCEntityHandlerCb,
295             NULL,
296             OC_DISCOVERABLE|OC_OBSERVABLE);
297     OC_LOG_V(INFO, TAG, "Created Light resource with result: %s", getResult(res));
298 }
299
300 const char *getResult(OCStackResult result) {
301     switch (result) {
302     case OC_STACK_OK:
303         return "OC_STACK_OK";
304     case OC_STACK_INVALID_URI:
305         return "OC_STACK_INVALID_URI";
306     case OC_STACK_INVALID_QUERY:
307         return "OC_STACK_INVALID_QUERY";
308     case OC_STACK_INVALID_IP:
309         return "OC_STACK_INVALID_IP";
310     case OC_STACK_INVALID_PORT:
311         return "OC_STACK_INVALID_PORT";
312     case OC_STACK_INVALID_CALLBACK:
313         return "OC_STACK_INVALID_CALLBACK";
314     case OC_STACK_INVALID_METHOD:
315         return "OC_STACK_INVALID_METHOD";
316     case OC_STACK_NO_MEMORY:
317         return "OC_STACK_NO_MEMORY";
318     case OC_STACK_COMM_ERROR:
319         return "OC_STACK_COMM_ERROR";
320     case OC_STACK_INVALID_PARAM:
321         return "OC_STACK_INVALID_PARAM";
322     case OC_STACK_NOTIMPL:
323         return "OC_STACK_NOTIMPL";
324     case OC_STACK_NO_RESOURCE:
325         return "OC_STACK_NO_RESOURCE";
326     case OC_STACK_RESOURCE_ERROR:
327         return "OC_STACK_RESOURCE_ERROR";
328     case OC_STACK_SLOW_RESOURCE:
329         return "OC_STACK_SLOW_RESOURCE";
330     case OC_STACK_NO_OBSERVERS:
331         return "OC_STACK_NO_OBSERVERS";
332     case OC_STACK_ERROR:
333         return "OC_STACK_ERROR";
334     default:
335         return "UNKNOWN";
336     }
337 }
338