diff --git a/examples/osd/er-rest-example-dht11/Makefile b/examples/osd/er-rest-example-dht11/Makefile new file mode 100644 index 000000000..ea3722d59 --- /dev/null +++ b/examples/osd/er-rest-example-dht11/Makefile @@ -0,0 +1,88 @@ +all: er-example-server er-example-client +# Use this target explicitly if requried: er-plugtest-server + +CONTIKI=../../.. +CFLAGS += -DPROJECT_CONF_H=\"project-conf.h\" + +# for static routing, if enabled +ifneq ($(TARGET), minimal-net) +ifneq ($(TARGET), native) +ifneq ($(findstring avr,$(TARGET)), avr) +PROJECT_SOURCEFILES += static-routing.c +endif +endif +endif + +# variable for root Makefile.include +WITH_UIP6=1 +# for some platforms +UIP_CONF_IPV6=1 + +# variable for this Makefile +# configure CoAP implementation (3|7) (er-coap-07 also supports CoAP draft 08) +WITH_COAP=7 + +# new variable since slip-radio +ifneq ($(TARGET), minimal-net) +UIP_CONF_RPL=1 +else +# minimal-net does not support RPL under Linux and is mostly used to test CoAP only +${info INFO: compiling without RPL} +UIP_CONF_RPL=0 +CFLAGS += -DUIP_CONF_ND6_DEF_MAXDADNS=0 +CFLAGS += -DHARD_CODED_ADDRESS=\"fdfd::10\" +CFLAGS += -DUIP_CONF_BUFFER_SIZE=1280 +endif + +# linker optimizations +SMALL=1 + +# REST framework, requires WITH_COAP +ifeq ($(WITH_COAP), 7) +${info INFO: compiling with CoAP-08} +CFLAGS += -DWITH_COAP=7 +CFLAGS += -DREST=coap_rest_implementation +CFLAGS += -DUIP_CONF_TCP=0 +APPS += er-coap-07 +else ifeq ($(WITH_COAP), 3) +${info INFO: compiling with CoAP-03} +CFLAGS += -DWITH_COAP=3 +CFLAGS += -DREST=coap_rest_implementation +CFLAGS += -DUIP_CONF_TCP=0 +APPS += er-coap-03 +else +${info INFO: compiling with HTTP} +CFLAGS += -DWITH_HTTP +CFLAGS += -DREST=http_rest_implementation +CFLAGS += -DUIP_CONF_TCP=1 +APPS += er-http-engine +endif + +APPS += erbium + +# optional rules to get assembly +#CUSTOM_RULE_C_TO_OBJECTDIR_O = 1 +#CUSTOM_RULE_S_TO_OBJECTDIR_O = 1 + +include $(CONTIKI)/Makefile.include + +# optional rules to get assembly +#$(OBJECTDIR)/%.o: asmdir/%.S +# $(CC) $(CFLAGS) -MMD -c $< -o $@ +# @$(FINALIZE_DEPENDENCY) +# +#asmdir/%.S: %.c +# $(CC) $(CFLAGS) -MMD -S $< -o $@ + +# border router rules +$(CONTIKI)/tools/tunslip6: $(CONTIKI)/tools/tunslip6.c + (cd $(CONTIKI)/tools && $(MAKE) tunslip6) + +connect-router: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 aaaa::1/64 + +connect-router-cooja: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 -a 127.0.0.1 aaaa::1/64 + +tap0up: + sudo ip address add fdfd::1/64 dev tap0 diff --git a/examples/osd/er-rest-example-dht11/README b/examples/osd/er-rest-example-dht11/README new file mode 100644 index 000000000..06283dc5e --- /dev/null +++ b/examples/osd/er-rest-example-dht11/README @@ -0,0 +1,88 @@ +A Quick Introduction to the Erbium (Er) REST Engine +=================================================== + +sudo avrdude -pm128rfa1 -c arduino -P/dev/ttyUSB0 -b57600 -e -U flash:w:er-example-server.osd-er-lp24.hex:a -U eeprom:w:er-example-server.osd-er-lp24.eep:a + +EXAMPLE FILES +------------- +er-example-server.c: A RESTful server example showing how to use the REST layer to develop server-side applications (at the moment only CoAP is implemented for the REST Engine). +er-example-client.c: A CoAP client that polls the /actuators/toggle resource every 10 seconds and cycles through 4 resources on button press (target address is hard-coded). +er-plugtest-server.c: The server used for draft compliance testing at ETSI IoT CoAP Plugtest in Paris, France, March 2012 (configured for minimal-net). + +PRELIMINARIES +------------- +- Make sure rpl-border-router has the same stack and fits into mote memory: + You can disable RDC in border-router project-conf.h (not really required as BR keeps radio turned on). + #undef NETSTACK_CONF_RDC + #define NETSTACK_CONF_RDC nullrdc_driver +- For convenience, define the Cooja addresses in /etc/hosts + aaaa::0212:7401:0001:0101 cooja1 + aaaa::0212:7402:0002:0202 cooja2 + ... +- Get the Copper (Cu) CoAP user-agent from https://addons.mozilla.org/en-US/firefox/addon/copper-270430/ +- Optional: Save your target as default target + $ make TARGET=sky savetarget + +COOJA HOWTO +----------- +Server only: +1) $ make TARGET=cooja server-only.csc +2) Open new terminal +3) $ make connect-router-cooja +4) Start Copper and discover resources at coap://cooja2:5683/ +- Choose "Click button on Sky 2" from the context menu of mote 2 (server) after requesting /test/separate +- Do the same when observing /test/event + +With client: +1) $ make TARGET=cooja server-client.csc +2) Open new terminal +3) $ make connect-router-cooja +4) Wait until red LED toggles on mote 2 (server) +5) Choose "Click button on Sky 3" from the context menu of mote 3 (client) and watch serial output + +TMOTES HOWTO +------------ +Server: +1) Connect two Tmote Skys (check with $ make TARGET=sky sky-motelist) +2) $ make TARGET=sky er-example-server.upload MOTE=2 +3) $ make TARGET=sky login MOTE=2 +4) Press reset button, get address, abort with Ctrl+C: + Line: "Tentative link-local IPv6 address fe80:0000:0000:0000:____:____:____:____" +5) $ cd ../ipv6/rpl-border-router/ +6) $ make TARGET=sky border-router.upload MOTE=1 +7) $ make connect-router + For a BR tty other than USB0: $ make connect-router-port PORT=X +8) Start Copper and discover resources at coap://[aaaa::____:____:____:____]:5683/ + +Add a client: +1) Change the hard-coded server address in er-example-client.c to aaaa::____:____:____:____ +2) Connect a third Tmote Sky +3) $ make TARGET=sky er-example-client.upload MOTE=3 + +DETAILS +------- +Erbium currently implements draft 08 (name "er-coap-07" stems from last technical draft changes). +Central features are commented in er-example-server.c. +In general, apps/er-coap-07 supports: +* All draft 08 header options +* CON Retransmissions (note COAP_MAX_OPEN_TRANSACTIONS) +* Blockwise Transfers (note REST_MAX_CHUNK_SIZE, see er-plugtest-server.c for Block1 uploads) +* Separate Responses (no rest_set_pre_handler() required anymore, note coap_separate_accept(), _reject(), and _resume()) +* Resource Discovery +* Observing Resources (see EVENT_ and PRERIODIC_RESOURCE, note COAP_MAX_OBSERVERS) + +REST IMPLEMENTATIONS +-------------------- +The Makefile uses WITH_COAP to configure different implementations for the Erbium (Er) REST Engine. +* WITH_COAP=7 uses Erbium CoAP 08 apps/er-coap-07/. + The default port for coap-07/-08 is 5683. +* WITH_COAP=3 uses Erbium CoAP 03 apps/er-coap-03/. + The default port for coap-03 is 61616. + er-coap-03 produces some warnings, as it not fully maintained anymore. +* WITH_COAP=0 is a stub to link an Erbium HTTP engine that uses the same resource abstraction (REST.x() functions and RESOURCE macros. + +TODOs +----- +* Observe client +* Multiple If-Match ETags +* (Message deduplication) diff --git a/examples/osd/er-rest-example-dht11/er-example-client.c b/examples/osd/er-rest-example-dht11/er-example-client.c new file mode 100644 index 000000000..d1d543cf0 --- /dev/null +++ b/examples/osd/er-rest-example-dht11/er-example-client.c @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2011, Matthias Kovatsch and other contributors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Erbium (Er) CoAP client example + * \author + * Matthias Kovatsch + */ + +#include +#include +#include + +#include "contiki.h" +#include "contiki-net.h" + +#if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) && !defined (CONTIKI_TARGET_NATIVE) +#warning "Compiling with static routing!" +#include "static-routing.h" +#endif + +#include "dev/button-sensor.h" + +#if WITH_COAP == 3 +#include "er-coap-03-engine.h" +#elif WITH_COAP == 6 +#include "er-coap-06-engine.h" +#elif WITH_COAP == 7 +#include "er-coap-07-engine.h" +#else +#error "CoAP version defined by WITH_COAP not implemented" +#endif + + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((uint8_t *)addr)[0], ((uint8_t *)addr)[1], ((uint8_t *)addr)[2], ((uint8_t *)addr)[3], ((uint8_t *)addr)[4], ((uint8_t *)addr)[5], ((uint8_t *)addr)[6], ((uint8_t *)addr)[7], ((uint8_t *)addr)[8], ((uint8_t *)addr)[9], ((uint8_t *)addr)[10], ((uint8_t *)addr)[11], ((uint8_t *)addr)[12], ((uint8_t *)addr)[13], ((uint8_t *)addr)[14], ((uint8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +/* TODO: This server address is hard-coded for Cooja. */ +#define SERVER_NODE(ipaddr) uip_ip6addr(ipaddr, 0xaaaa, 0, 0, 0, 0x0212, 0x7402, 0x0002, 0x0202) /* cooja2 */ + +#define LOCAL_PORT UIP_HTONS(COAP_DEFAULT_PORT+1) +#define REMOTE_PORT UIP_HTONS(COAP_DEFAULT_PORT) + +#define TOGGLE_INTERVAL 10 + +PROCESS(coap_client_example, "COAP Client Example"); +AUTOSTART_PROCESSES(&coap_client_example); + + +uip_ipaddr_t server_ipaddr; +static struct etimer et; + +/* Example URIs that can be queried. */ +#define NUMBER_OF_URLS 4 +/* leading and ending slashes only for demo purposes, get cropped automatically when setting the Uri-Path */ +char* service_urls[NUMBER_OF_URLS] = {".well-known/core", "/actuators/toggle", "battery/", "error/in//path"}; +#if PLATFORM_HAS_BUTTON +static int uri_switch = 0; +#endif + +/* This function is will be passed to COAP_BLOCKING_REQUEST() to handle responses. */ +void +client_chunk_handler(void *response) +{ + uint8_t *chunk; + + int len = coap_get_payload(response, &chunk); + printf("|%.*s", len, (char *)chunk); +} + + +PROCESS_THREAD(coap_client_example, ev, data) +{ + PROCESS_BEGIN(); + + static coap_packet_t request[1]; /* This way the packet can be treated as pointer as usual. */ + SERVER_NODE(&server_ipaddr); + + /* receives all CoAP messages */ + coap_receiver_init(); + + etimer_set(&et, TOGGLE_INTERVAL * CLOCK_SECOND); + +#if PLATFORM_HAS_BUTTON + SENSORS_ACTIVATE(button_sensor); + printf("Press a button to request %s\n", service_urls[uri_switch]); +#endif + + while(1) { + PROCESS_YIELD(); + + if (etimer_expired(&et)) { + printf("--Toggle timer--\n"); + + /* prepare request, TID is set by COAP_BLOCKING_REQUEST() */ + coap_init_message(request, COAP_TYPE_CON, COAP_POST, 0 ); + coap_set_header_uri_path(request, service_urls[1]); + + const char msg[] = "Toggle!"; + coap_set_payload(request, (uint8_t *)msg, sizeof(msg)-1); + + + PRINT6ADDR(&server_ipaddr); + PRINTF(" : %u\n", UIP_HTONS(REMOTE_PORT)); + + COAP_BLOCKING_REQUEST(&server_ipaddr, REMOTE_PORT, request, client_chunk_handler); + + printf("\n--Done--\n"); + + etimer_reset(&et); + +#if PLATFORM_HAS_BUTTON + } else if (ev == sensors_event && data == &button_sensor) { + + /* send a request to notify the end of the process */ + + coap_init_message(request, COAP_TYPE_CON, COAP_GET, 0); + coap_set_header_uri_path(request, service_urls[uri_switch]); + + printf("--Requesting %s--\n", service_urls[uri_switch]); + + PRINT6ADDR(&server_ipaddr); + PRINTF(" : %u\n", UIP_HTONS(REMOTE_PORT)); + + COAP_BLOCKING_REQUEST(&server_ipaddr, REMOTE_PORT, request, client_chunk_handler); + + printf("\n--Done--\n"); + + uri_switch = (uri_switch+1) % NUMBER_OF_URLS; +#endif + + } + } + + PROCESS_END(); +} diff --git a/examples/osd/er-rest-example-dht11/er-example-server.c b/examples/osd/er-rest-example-dht11/er-example-server.c new file mode 100644 index 000000000..b6c1a84de --- /dev/null +++ b/examples/osd/er-rest-example-dht11/er-example-server.c @@ -0,0 +1,1189 @@ +/* + * Copyright (c) 2011, Matthias Kovatsch and other contributors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Erbium (Er) REST Engine example (with CoAP-specific code) + * \author + * Matthias Kovatsch + */ + +#include +#include +#include +#include "contiki.h" +#include "contiki-net.h" + + +/* Define which resources to include to meet memory constraints. */ +#define REST_RES_INFO 1 +#define REST_RES_DS1820 0 +#define REST_RES_DHT11 1 +#define REST_RES_HELLO 0 +#define REST_RES_MIRROR 0 /* causes largest code size */ +#define REST_RES_CHUNKS 0 +#define REST_RES_SEPARATE 0 +#define REST_RES_PUSHING 0 +#define REST_RES_EVENT 0 +#define REST_RES_SUB 0 +#define REST_RES_LEDS 0 +#define REST_RES_TOGGLE 0 +#define REST_RES_LIGHT 0 +#define REST_RES_BATTERY 0 +#define REST_RES_RADIO 0 + + + +#if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) && !defined (CONTIKI_TARGET_NATIVE) +#warning "Compiling with static routing!" +#include "static-routing.h" +#endif + +#include "erbium.h" + +// todo OSD-Testboard move to platform/dev +#include "dev/key.h" +#include "dev/led.h" +#if REST_RES_DS1820 +#include "dev/ds1820.h" +#endif +#if REST_RES_DHT11 +#include "dev/dht11.h" +uint8_t out_temp=0, humidity=0; +#endif + +#if defined (PLATFORM_HAS_BUTTON) +#include "dev/button-sensor.h" +#endif +#if defined (PLATFORM_HAS_LEDS) +#include "dev/leds.h" +#endif +#if defined (PLATFORM_HAS_LIGHT) +#include "dev/light-sensor.h" +#endif +#if defined (PLATFORM_HAS_BATTERY) +#include "dev/battery-sensor.h" +#endif +#if defined (PLATFORM_HAS_SHT11) +#include "dev/sht11-sensor.h" +#endif +#if defined (PLATFORM_HAS_RADIO) +#include "dev/radio-sensor.h" +#endif + + +/* For CoAP-specific example: not required for normal RESTful Web service. */ +#if WITH_COAP == 3 +#include "er-coap-03.h" +#elif WITH_COAP == 7 +#include "er-coap-07.h" +#else +#warning "Erbium example without CoAP-specifc functionality" +#endif /* CoAP-specific example */ + +#define DEBUG 0 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((uint8_t *)addr)[0], ((uint8_t *)addr)[1], ((uint8_t *)addr)[2], ((uint8_t *)addr)[3], ((uint8_t *)addr)[4], ((uint8_t *)addr)[5], ((uint8_t *)addr)[6], ((uint8_t *)addr)[7], ((uint8_t *)addr)[8], ((uint8_t *)addr)[9], ((uint8_t *)addr)[10], ((uint8_t *)addr)[11], ((uint8_t *)addr)[12], ((uint8_t *)addr)[13], ((uint8_t *)addr)[14], ((uint8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +#include "dev/key.c" // todo: move platform /dev +#include "dev/led.c" +#if REST_RES_DS1820 +#include "dev/ds1820.c" +#endif + +/******************************************************************************/ + +#if REST_RES_INFO +/* + * Resources are defined by the RESOURCE macro. + * Signature: resource name, the RESTful methods it handles, and its URI path (omitting the leading slash). + */ +RESOURCE(info, METHOD_GET, "info", "title=\"Info\";rt=\"Text\""); + +/* + * A handler function named [resource name]_handler must be implemented for each RESOURCE. + * A buffer for the response payload is provided through the buffer pointer. Simple resources can ignore + * preferred_size and offset, but must respect the REST_MAX_CHUNK_SIZE limit for the buffer. + * If a smaller block size is requested for CoAP, the REST framework automatically splits the data. + */ +void +info_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + char message[100]; + int index = 0; + int length = 0; /* |<-------->| */ + + /* Some data that has the length up to REST_MAX_CHUNK_SIZE. For more, see the chunk resource. */ + // jSON Format + index += sprintf(message + index,"{\n \"version\" : \"V0.3\",\n"); + index += sprintf(message + index," \"name\" : \"Button,LED\"\n"); + index += sprintf(message + index,"}\n"); + + length = strlen(message); + memcpy(buffer, message,length ); + + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + REST.set_response_payload(response, buffer, length); +} +#endif + +// mybutton +/*A simple actuator example. read the key button status*/ +RESOURCE(button, METHOD_GET | METHOD_PUT , "button", "title=\"Button\";rt=\"Text\""); +void +button_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + static char bname[17]="button1"; + int success = 1; + + char temp[100]; + int index = 0; + int length = 0; /* |<-------->| */ + const char *name = NULL; + size_t len = 0; + + switch(REST.get_method_type(request)){ + case METHOD_GET: + // jSON Format + index += sprintf(temp + index,"{\n \"name\" : \"%s\",\n",bname); + if(is_button()) + index += sprintf(temp + index," \"state\" : \"on\"\n"); + else + index += sprintf(temp + index," \"state\" : \"off\"\n"); + index += sprintf(temp + index,"}\n"); + + length = strlen(temp); + memcpy(buffer, temp,length ); + + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + REST.set_response_payload(response, buffer, length); + + break; + case METHOD_PUT: + + if (success && (len=REST.get_post_variable(request, "name", &name))) { + PRINTF("name %s\n", name); + memcpy(bname, name,len); + bname[len]=0; + } else { + success = 0; + } + break; + default: + success = 0; + } + if (!success) { + REST.set_response_status(response, REST.status.BAD_REQUEST); + } +} + +/*A simple actuator example, post variable mode, relay is activated or deactivated*/ +RESOURCE(led1, METHOD_GET | METHOD_PUT , "led1", "title=\"Led1\";rt=\"Text\""); +void +led1_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + char mode[10]; + static uint8_t led1 = 0; + static char name[17]="led1"; + int success = 1; + + char temp[100]; + int index = 0; + size_t len = 0; + + const char *pmode = NULL; + const char *pname = NULL; + + switch(REST.get_method_type(request)){ + case METHOD_GET: + // jSON Format + index += sprintf(temp + index,"{\n \"name\" : \"%s\",\n",name); + if(led1 == 0) + index += sprintf(temp + index," \"mode\" : \"off\"\n"); + if(led1 == 1) + index += sprintf(temp + index," \"mode\" : \"on\"\n"); + index += sprintf(temp + index,"}\n"); + + len = strlen(temp); + memcpy(buffer, temp,len ); + + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + REST.set_response_payload(response, buffer, len); + break; + case METHOD_POST: + success = 0; + break; + case METHOD_PUT: + if (success && (len=REST.get_post_variable(request, "mode", &pmode))) { + PRINTF("name %s\n", mode); + memcpy(mode, pmode,len); + mode[len]=0; + if (!strcmp(mode, "on")) { + led1_on(); + led1 = 1; + } else if (!strcmp(mode, "off")) { + led1_off(); + led1 = 0; + } else { + success = 0; + } + } else if (success && (len=REST.get_post_variable(request, "name", &pname))) { + PRINTF("name %s\n", name); + memcpy(name, pname,len); + name[len]=0; + } else { + success = 0; + } + break; + default: + success = 0; + } + + if (!success) { + REST.set_response_status(response, REST.status.BAD_REQUEST); + } +} + +#if REST_RES_DS1820 +/*A simple getter example. Returns the reading from ds1820 sensor*/ +RESOURCE(ds1820, METHOD_GET, "DS1820", "title=\"Temperatur\";rt=\"Temperatur\""); +void +ds1820_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + char message[100]; + int length = 0; /* |<-------->| */ + int ret=0; + int grad=0; + int kgrad=0; +// ret=ds1820_temp(); + if(ds1820_ok[0] & 0x01){ + kgrad=5; + } + grad = (int)((ds1820_ok[1] << 8) | (ds1820_ok[0])) >> 1; + + uint16_t *accept = NULL; + int num = REST.get_header_accept(request, &accept); + + if ((num==0) || (num && accept[0]==REST.type.TEXT_PLAIN)) + { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf(message, REST_MAX_CHUNK_SIZE, "%2d.%d °C",grad,kgrad); + + length = strlen(message); + memcpy(buffer, message,length ); + + REST.set_response_payload(response, buffer, length); + } + else if (num && (accept[0]==REST.type.APPLICATION_JSON)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf(message, REST_MAX_CHUNK_SIZE, "{\"temp\":\"%d.%d °C\"}",grad,kgrad); + + length = strlen(message); + memcpy(buffer, message,length ); + + REST.set_response_payload(response, buffer, length); + } + else + { + REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE); + REST.set_response_payload(response, (uint8_t *)"Supporting content-types text/plain and application/json", 56); + } +} +#endif //REST_RES_DS1820 + +#if REST_RES_DHT11 +/*A simple getter example. Returns the reading from ds1820 sensor*/ +RESOURCE(dht11, METHOD_GET, "DHT11", "title=\"TempHumidity\";rt=\"Temperatur\""); +void +dht11_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + char message[100]; + int length = 0; /* |<-------->| */ + int ret=0; +// out_temp=DHT_Read_Data(DHT_Temp); +// humidity=DHT_Read_Data(DHT_RH); + + uint16_t *accept = NULL; + int num = REST.get_header_accept(request, &accept); + + if ((num==0) || (num && accept[0]==REST.type.TEXT_PLAIN)) + { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf(message, REST_MAX_CHUNK_SIZE, "%2d %2d",out_temp,humidity); + + length = strlen(message); + memcpy(buffer, message,length ); + + REST.set_response_payload(response, buffer, length); + } + else if (num && (accept[0]==REST.type.APPLICATION_JSON)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf(message, REST_MAX_CHUNK_SIZE, "{\"temp\":\"%d\",\"hum\":\"%d\"}",out_temp,humidity); + + length = strlen(message); + memcpy(buffer, message,length ); + + REST.set_response_payload(response, buffer, length); + } + else + { + REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE); + REST.set_response_payload(response, (uint8_t *)"Supporting content-types text/plain and application/json", 56); + } +} +#endif //REST_RES_DHT11 + +#if REST_RES_HELLO +/* + * Resources are defined by the RESOURCE macro. + * Signature: resource name, the RESTful methods it handles, and its URI path (omitting the leading slash). + */ +RESOURCE(helloworld, METHOD_GET, "hello", "title=\"Hello world: ?len=0..\";rt=\"Text\""); + +/* + * A handler function named [resource name]_handler must be implemented for each RESOURCE. + * A buffer for the response payload is provided through the buffer pointer. Simple resources can ignore + * preferred_size and offset, but must respect the REST_MAX_CHUNK_SIZE limit for the buffer. + * If a smaller block size is requested for CoAP, the REST framework automatically splits the data. + */ +void +helloworld_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + const char *len = NULL; + /* Some data that has the length up to REST_MAX_CHUNK_SIZE. For more, see the chunk resource. */ + char const * const message = "Hello World! ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxy"; + int length = 12; /* |<-------->| */ + + /* The query string can be retrieved by rest_get_query() or parsed for its key-value pairs. */ + if (REST.get_query_variable(request, "len", &len)) { + length = atoi(len); + if (length<0) length = 0; + if (length>REST_MAX_CHUNK_SIZE) length = REST_MAX_CHUNK_SIZE; + memcpy(buffer, message, length); + } else { + memcpy(buffer, message, length); + } + + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); /* text/plain is the default, hence this option could be omitted. */ + REST.set_header_etag(response, (uint8_t *) &length, 1); + REST.set_response_payload(response, buffer, length); +} +#endif + +/******************************************************************************/ +#if REST_RES_MIRROR +/* This resource mirrors the incoming request. It shows how to access the options and how to set them for the response. */ +RESOURCE(mirror, METHOD_GET | METHOD_POST | METHOD_PUT | METHOD_DELETE, "debug/mirror", "title=\"Returns your decoded message\";rt=\"Debug\""); + +void +mirror_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + /* The ETag and Token is copied to the header. */ + uint8_t opaque[] = {0x0A, 0xBC, 0xDE}; + + /* Strings are not copied, so use static string buffers or strings in .text memory (char *str = "string in .text";). */ + static char location[] = {'/','f','/','a','?','k','&','e', 0}; + + /* Getter for the header option Content-Type. If the option is not set, text/plain is returned by default. */ + unsigned int content_type = REST.get_header_content_type(request); + + /* The other getters copy the value (or string/array pointer) to the given pointers and return 1 for success or the length of strings/arrays. */ + uint32_t max_age = 0; + const char *str = NULL; + uint32_t observe = 0; + const uint8_t *bytes = NULL; + uint32_t block_num = 0; + uint8_t block_more = 0; + uint16_t block_size = 0; + const char *query = ""; + int len = 0; + + /* Mirror the received header options in the response payload. Unsupported getters (e.g., rest_get_header_observe() with HTTP) will return 0. */ + + int strpos = 0; + /* snprintf() counts the terminating '\0' to the size parameter. + * The additional byte is taken care of by allocating REST_MAX_CHUNK_SIZE+1 bytes in the REST framework. + * Add +1 to fill the complete buffer. */ + strpos += snprintf((char *)buffer, REST_MAX_CHUNK_SIZE+1, "CT %u\n", content_type); + + /* Some getters such as for ETag or Location are omitted, as these options should not appear in a request. + * Max-Age might appear in HTTP requests or used for special purposes in CoAP. */ + if (strpos<=REST_MAX_CHUNK_SIZE && REST.get_header_max_age(request, &max_age)) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "MA %lu\n", max_age); + } + + if (strpos<=REST_MAX_CHUNK_SIZE && (len = REST.get_header_host(request, &str))) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "UH %.*s\n", len, str); + } + +/* CoAP-specific example: actions not required for normal RESTful Web service. */ +#if WITH_COAP > 1 + if (strpos<=REST_MAX_CHUNK_SIZE && coap_get_header_observe(request, &observe)) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "Ob %lu\n", observe); + } + if (strpos<=REST_MAX_CHUNK_SIZE && (len = coap_get_header_token(request, &bytes))) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "To 0x"); + int index = 0; + for (index = 0; index 03 */ +#endif /* CoAP-specific example */ + + if (strpos<=REST_MAX_CHUNK_SIZE && (len = REST.get_query(request, &query))) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "Qu %.*s\n", len, query); + } + if (strpos<=REST_MAX_CHUNK_SIZE && (len = REST.get_request_payload(request, &bytes))) + { + strpos += snprintf((char *)buffer+strpos, REST_MAX_CHUNK_SIZE-strpos+1, "%.*s", len, bytes); + } + + if (strpos >= REST_MAX_CHUNK_SIZE) + { + buffer[REST_MAX_CHUNK_SIZE-1] = 0xBB; /* '»' to indicate truncation */ + } + + REST.set_response_payload(response, buffer, strpos); + + PRINTF("/mirror options received: %s\n", buffer); + + /* Set dummy header options for response. Like getters, some setters are not implemented for HTTP and have no effect. */ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + REST.set_header_max_age(response, 10); /* For HTTP, browsers will not re-request the page for 10 seconds. CoAP action depends on the client. */ + REST.set_header_etag(response, opaque, 2); + REST.set_header_location(response, location); /* Initial slash is omitted by framework */ + +/* CoAP-specific example: actions not required for normal RESTful Web service. */ +#if WITH_COAP > 1 + coap_set_header_uri_host(response, "tiki"); + coap_set_header_observe(response, 10); +#if WITH_COAP == 3 + coap_set_header_block(response, 42, 0, 64); /* The block option might be overwritten by the framework when blockwise transfer is requested. */ +#else + coap_set_header_proxy_uri(response, "ftp://x"); + coap_set_header_block2(response, 42, 0, 64); /* The block option might be overwritten by the framework when blockwise transfer is requested. */ + coap_set_header_block1(response, 23, 0, 16); + coap_set_header_accept(response, TEXT_PLAIN); + coap_set_header_if_none_match(response); +#endif /* CoAP > 03 */ +#endif /* CoAP-specific example */ +} +#endif /* REST_RES_MIRROR */ + +/******************************************************************************/ +#if REST_RES_CHUNKS +/* + * For data larger than REST_MAX_CHUNK_SIZE (e.g., stored in flash) resources must be aware of the buffer limitation + * and split their responses by themselves. To transfer the complete resource through a TCP stream or CoAP's blockwise transfer, + * the byte offset where to continue is provided to the handler as int32_t pointer. + * These chunk-wise resources must set the offset value to its new position or -1 of the end is reached. + * (The offset for CoAP's blockwise transfer can go up to 2'147'481'600 = ~2047 M for block size 2048 (reduced to 1024 in observe-03.) + */ +RESOURCE(chunks, METHOD_GET, "test/chunks", "title=\"Blockwise demo\";rt=\"Data\""); + +#define CHUNKS_TOTAL 2050 + +void +chunks_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + int32_t strpos = 0; + + /* Check the offset for boundaries of the resource data. */ + if (*offset>=CHUNKS_TOTAL) + { + REST.set_response_status(response, REST.status.BAD_OPTION); + /* A block error message should not exceed the minimum block size (16). */ + + const char *error_msg = "BlockOutOfScope"; + REST.set_response_payload(response, error_msg, strlen(error_msg)); + return; + } + + /* Generate data until reaching CHUNKS_TOTAL. */ + while (strpos preferred_size) + { + strpos = preferred_size; + } + + /* Truncate if above CHUNKS_TOTAL bytes. */ + if (*offset+(int32_t)strpos > CHUNKS_TOTAL) + { + strpos = CHUNKS_TOTAL - *offset; + } + + REST.set_response_payload(response, buffer, strpos); + + /* IMPORTANT for chunk-wise resources: Signal chunk awareness to REST engine. */ + *offset += strpos; + + /* Signal end of resource representation. */ + if (*offset>=CHUNKS_TOTAL) + { + *offset = -1; + } +} +#endif + +/******************************************************************************/ +#if REST_RES_SEPARATE && defined (PLATFORM_HAS_BUTTON) && WITH_COAP > 3 +/* Required to manually (=not by the engine) handle the response transaction. */ +#include "er-coap-07-separate.h" +#include "er-coap-07-transactions.h" +/* + * CoAP-specific example for separate responses. + * Note the call "rest_set_pre_handler(&resource_separate, coap_separate_handler);" in the main process. + * The pre-handler takes care of the empty ACK and updates the MID and message type for CON requests. + * The resource handler must store all information that required to finalize the response later. + */ +RESOURCE(separate, METHOD_GET, "test/separate", "title=\"Separate demo\""); + +/* A structure to store the required information */ +typedef struct application_separate_store { + /* Provided by Erbium to store generic request information such as remote address and token. */ + coap_separate_t request_metadata; + /* Add fields for addition information to be stored for finalizing, e.g.: */ + char buffer[16]; +} application_separate_store_t; + +static uint8_t separate_active = 0; +static application_separate_store_t separate_store[1]; + +void +separate_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + /* + * Example allows only one open separate response. + * For multiple, the application must manage the list of stores. + */ + if (separate_active) + { + coap_separate_reject(); + } + else + { + separate_active = 1; + + /* Take over and skip response by engine. */ + coap_separate_accept(request, &separate_store->request_metadata); + /* Be aware to respect the Block2 option, which is also stored in the coap_separate_t. */ + + /* + * At the moment, only the minimal information is stored in the store (client address, port, token, MID, type, and Block2). + * Extend the store, if the application requires additional information from this handler. + * buffer is an example field for custom information. + */ + snprintf(separate_store->buffer, sizeof(separate_store->buffer), "StoredInfo"); + } +} + +void +separate_finalize_handler() +{ + if (separate_active) + { + coap_transaction_t *transaction = NULL; + if ( (transaction = coap_new_transaction(separate_store->request_metadata.mid, &separate_store->request_metadata.addr, separate_store->request_metadata.port)) ) + { + coap_packet_t response[1]; /* This way the packet can be treated as pointer as usual. */ + + /* Restore the request information for the response. */ + coap_separate_resume(response, &separate_store->request_metadata, CONTENT_2_05); + + coap_set_payload(response, separate_store->buffer, strlen(separate_store->buffer)); + + /* + * Be aware to respect the Block2 option, which is also stored in the coap_separate_t. + * As it is a critical option, this example resource pretends to handle it for compliance. + */ + coap_set_header_block2(response, separate_store->request_metadata.block2_num, 0, separate_store->request_metadata.block2_size); + + /* Warning: No check for serialization error. */ + transaction->packet_len = coap_serialize_message(response, transaction->packet); + coap_send_transaction(transaction); + /* The engine will clear the transaction (right after send for NON, after acked for CON). */ + + separate_active = 0; + } + else + { + /* + * Set timer for retry, send error message, ... + * The example simply waits for another button press. + */ + } + } /* if (separate_active) */ +} +#endif + +/******************************************************************************/ +#if REST_RES_PUSHING +/* + * Example for a periodic resource. + * It takes an additional period parameter, which defines the interval to call [name]_periodic_handler(). + * A default post_handler takes care of subscriptions by managing a list of subscribers to notify. + */ +PERIODIC_RESOURCE(pushing, METHOD_GET, "test/push", "title=\"Periodic demo\";obs", 5*CLOCK_SECOND); + +void +pushing_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + + /* Usually, a CoAP server would response with the resource representation matching the periodic_handler. */ + const char *msg = "It's periodic!"; + REST.set_response_payload(response, msg, strlen(msg)); + + /* A post_handler that handles subscriptions will be called for periodic resources by the REST framework. */ +} + +/* + * Additionally, a handler function named [resource name]_handler must be implemented for each PERIODIC_RESOURCE. + * It will be called by the REST manager process with the defined period. + */ +void +pushing_periodic_handler(resource_t *r) +{ + static uint16_t obs_counter = 0; + static char content[11]; + + ++obs_counter; + + PRINTF("TICK %u for /%s\n", obs_counter, r->url); + + /* Build notification. */ + coap_packet_t notification[1]; /* This way the packet can be treated as pointer as usual. */ + coap_init_message(notification, COAP_TYPE_NON, CONTENT_2_05, 0 ); + coap_set_payload(notification, content, snprintf(content, sizeof(content), "TICK %u", obs_counter)); + + /* Notify the registered observers with the given message type, observe option, and payload. */ + REST.notify_subscribers(r, obs_counter, notification); +} +#endif + +/******************************************************************************/ +#if REST_RES_EVENT && defined (PLATFORM_HAS_BUTTON) +/* + * Example for an event resource. + * Additionally takes a period parameter that defines the interval to call [name]_periodic_handler(). + * A default post_handler takes care of subscriptions and manages a list of subscribers to notify. + */ +EVENT_RESOURCE(event, METHOD_GET, "sensors/button", "title=\"Event demo\";obs"); + +void +event_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + /* Usually, a CoAP server would response with the current resource representation. */ + const char *msg = "It's eventful!"; + REST.set_response_payload(response, (uint8_t *)msg, strlen(msg)); + + /* A post_handler that handles subscriptions/observing will be called for periodic resources by the framework. */ +} + +/* Additionally, a handler function named [resource name]_event_handler must be implemented for each PERIODIC_RESOURCE defined. + * It will be called by the REST manager process with the defined period. */ +void +event_event_handler(resource_t *r) +{ + static uint16_t event_counter = 0; + static char content[12]; + + ++event_counter; + + PRINTF("TICK %u for /%s\n", event_counter, r->url); + + /* Build notification. */ + coap_packet_t notification[1]; /* This way the packet can be treated as pointer as usual. */ + coap_init_message(notification, COAP_TYPE_CON, CONTENT_2_05, 0 ); + coap_set_payload(notification, content, snprintf(content, sizeof(content), "EVENT %u", event_counter)); + + /* Notify the registered observers with the given message type, observe option, and payload. */ + REST.notify_subscribers(r, event_counter, notification); +} +#endif /* PLATFORM_HAS_BUTTON */ + +/******************************************************************************/ +#if REST_RES_SUB +/* + * Example for a resource that also handles all its sub-resources. + * Use REST.get_url() to multiplex the handling of the request depending on the Uri-Path. + */ +RESOURCE(sub, METHOD_GET | HAS_SUB_RESOURCES, "test/path", "title=\"Sub-resource demo\""); + +void +sub_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + + const char *uri_path = NULL; + int len = REST.get_url(request, &uri_path); + int base_len = strlen(resource_sub.url); + + if (len==base_len) + { + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "Request any sub-resource of /%s", resource_sub.url); + } + else + { + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, ".%s", uri_path+base_len); + } + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); +} +#endif + +/******************************************************************************/ +#if defined (PLATFORM_HAS_LEDS) +/******************************************************************************/ +#if REST_RES_LEDS +/*A simple actuator example, depending on the color query parameter and post variable mode, corresponding led is activated or deactivated*/ +RESOURCE(leds, METHOD_POST | METHOD_PUT , "actuators/leds", "title=\"LEDs: ?color=r|g|b, POST/PUT mode=on|off\";rt=\"Control\""); + +void +leds_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + size_t len = 0; + const char *color = NULL; + const char *mode = NULL; + uint8_t led = 0; + int success = 1; + + if ((len=REST.get_query_variable(request, "color", &color))) { + PRINTF("color %.*s\n", len, color); + + if (strncmp(color, "r", len)==0) { + led = LEDS_RED; + } else if(strncmp(color,"g", len)==0) { + led = LEDS_GREEN; + } else if (strncmp(color,"b", len)==0) { + led = LEDS_BLUE; + } else { + success = 0; + } + } else { + success = 0; + } + + if (success && (len=REST.get_post_variable(request, "mode", &mode))) { + PRINTF("mode %s\n", mode); + + if (strncmp(mode, "on", len)==0) { + leds_on(led); + } else if (strncmp(mode, "off", len)==0) { + leds_off(led); + } else { + success = 0; + } + } else { + success = 0; + } + + if (!success) { + REST.set_response_status(response, REST.status.BAD_REQUEST); + } +} +#endif + +/******************************************************************************/ +#if REST_RES_TOGGLE +/* A simple actuator example. Toggles the red led */ +RESOURCE(toggle, METHOD_GET | METHOD_PUT | METHOD_POST, "actuators/toggle", "title=\"Red LED\";rt=\"Control\""); +void +toggle_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + leds_toggle(LEDS_RED); +} +#endif +#endif /* PLATFORM_HAS_LEDS */ + +/******************************************************************************/ +#if REST_RES_LIGHT && defined (PLATFORM_HAS_LIGHT) +/* A simple getter example. Returns the reading from light sensor with a simple etag */ +RESOURCE(light, METHOD_GET, "sensors/light", "title=\"Photosynthetic and solar light (supports JSON)\";rt=\"LightSensor\""); +void +light_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + uint16_t light_photosynthetic = light_sensor.value(LIGHT_SENSOR_PHOTOSYNTHETIC); + uint16_t light_solar = light_sensor.value(LIGHT_SENSOR_TOTAL_SOLAR); + + const uint16_t *accept = NULL; + int num = REST.get_header_accept(request, &accept); + + if ((num==0) || (num && accept[0]==REST.type.TEXT_PLAIN)) + { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%u;%u", light_photosynthetic, light_solar); + + REST.set_response_payload(response, (uint8_t *)buffer, strlen((char *)buffer)); + } + else if (num && (accept[0]==REST.type.APPLICATION_XML)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_XML); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "", light_photosynthetic, light_solar); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } + else if (num && (accept[0]==REST.type.APPLICATION_JSON)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'light':{'photosynthetic':%u,'solar':%u}}", light_photosynthetic, light_solar); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } + else + { + REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE); + const char *msg = "Supporting content-types text/plain, application/xml, and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} +#endif /* PLATFORM_HAS_LIGHT */ + +/******************************************************************************/ +#if REST_RES_BATTERY && defined (PLATFORM_HAS_BATTERY) +/* A simple getter example. Returns the reading from light sensor with a simple etag */ +RESOURCE(battery, METHOD_GET, "sensors/battery", "title=\"Battery status\";rt=\"Battery\""); +void +battery_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + int battery = battery_sensor.value(0); + + const uint16_t *accept = NULL; + int num = REST.get_header_accept(request, &accept); + + if ((num==0) || (num && accept[0]==REST.type.TEXT_PLAIN)) + { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%d", battery); + + REST.set_response_payload(response, (uint8_t *)buffer, strlen((char *)buffer)); + } + else if (num && (accept[0]==REST.type.APPLICATION_JSON)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'battery':%d}", battery); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } + else + { + REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} +#endif /* PLATFORM_HAS_BATTERY */ + + +#if defined (PLATFORM_HAS_RADIO) && REST_RES_RADIO +/* A simple getter example. Returns the reading of the rssi/lqi from radio sensor */ +RESOURCE(radio, METHOD_GET, "sensor/radio", "title=\"RADIO: ?p=lqi|rssi\";rt=\"RadioSensor\""); + +void +radio_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + size_t len = 0; + const char *p = NULL; + uint8_t param = 0; + int success = 1; + + const uint16_t *accept = NULL; + int num = REST.get_header_accept(request, &accept); + + if ((len=REST.get_query_variable(request, "p", &p))) { + PRINTF("p %.*s\n", len, p); + if (strncmp(p, "lqi", len)==0) { + param = RADIO_SENSOR_LAST_VALUE; + } else if(strncmp(p,"rssi", len)==0) { + param = RADIO_SENSOR_LAST_PACKET; + } else { + success = 0; + } + } else { + success = 0; + } + + if (success) { + if ((num==0) || (num && accept[0]==REST.type.TEXT_PLAIN)) + { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%d", radio_sensor.value(param)); + + REST.set_response_payload(response, (uint8_t *)buffer, strlen((char *)buffer)); + } + else if (num && (accept[0]==REST.type.APPLICATION_JSON)) + { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + + if (param == RADIO_SENSOR_LAST_VALUE) { + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'lqi':%d}", radio_sensor.value(param)); + } else if (param == RADIO_SENSOR_LAST_PACKET) { + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'rssi':%d}", radio_sensor.value(param)); + } + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } + else + { + REST.set_response_status(response, REST.status.UNSUPPORTED_MADIA_TYPE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } + } else { + REST.set_response_status(response, REST.status.BAD_REQUEST); + } +} +#endif + +void +hw_init() +{ + key_init(); + led1_off(); +#if REST_RES_DS1820 + ds1820_temp(); +#endif +#if REST_RES_DHT11 + out_temp=DHT_Read_Data(DHT_Temp); + humidity=DHT_Read_Data(DHT_RH); +#endif +} +#define MESURE_INTERVAL (20 * CLOCK_SECOND) +#define READ_TIME ( 2 * CLOCK_SECOND) + +PROCESS(rest_server_example, "Erbium Example Server"); +AUTOSTART_PROCESSES(&rest_server_example); + +PROCESS_THREAD(rest_server_example, ev, data) +{ + static struct etimer ds_periodic_timer; +#if REST_RES_DS1820 + static struct etimer ds_read_timer; +#endif + + PROCESS_BEGIN(); + + + + PRINTF("Starting Erbium Example Server\n"); + +#ifdef RF_CHANNEL + PRINTF("RF channel: %u\n", RF_CHANNEL); +#endif +#ifdef IEEE802154_PANID + PRINTF("PAN ID: 0x%04X\n", IEEE802154_PANID); +#endif + + PRINTF("uIP buffer: %u\n", UIP_BUFSIZE); + PRINTF("LL header: %u\n", UIP_LLH_LEN); + PRINTF("IP+UDP header: %u\n", UIP_IPUDPH_LEN); + PRINTF("REST max chunk: %u\n", REST_MAX_CHUNK_SIZE); + +/* if static routes are used rather than RPL */ +#if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) && !defined (CONTIKI_TARGET_NATIVE) + set_global_address(); + configure_routing(); +#endif + + /* Initialize the OSD Hardware. */ + hw_init(); + + /* Initialize the REST engine. */ + rest_init_engine(); + + /* Activate the application-specific resources. */ + rest_activate_resource(&resource_button); + rest_activate_resource(&resource_led1); + /* Activate the application-specific resources. */ +#if REST_RES_DS1820 + rest_activate_resource(&resource_ds1820); +#endif +#if REST_RES_DHT11 + rest_activate_resource(&resource_dht11); +#endif +#if REST_RES_INFO + rest_activate_resource(&resource_info); +#endif +#if REST_RES_HELLO + rest_activate_resource(&resource_helloworld); +#endif +#if REST_RES_MIRROR + rest_activate_resource(&resource_mirror); +#endif +#if REST_RES_CHUNKS + rest_activate_resource(&resource_chunks); +#endif +#if REST_RES_PUSHING + rest_activate_periodic_resource(&periodic_resource_pushing); +#endif +#if defined (PLATFORM_HAS_BUTTON) && REST_RES_EVENT + rest_activate_event_resource(&resource_event); +#endif +#if defined (PLATFORM_HAS_BUTTON) && REST_RES_SEPARATE && WITH_COAP > 3 + /* No pre-handler anymore, user coap_separate_accept() and coap_separate_reject(). */ + rest_activate_resource(&resource_separate); +#endif +#if defined (PLATFORM_HAS_BUTTON) && (REST_RES_EVENT || (REST_RES_SEPARATE && WITH_COAP > 3)) + SENSORS_ACTIVATE(button_sensor); +#endif +#if REST_RES_SUB + rest_activate_resource(&resource_sub); +#endif +#if defined (PLATFORM_HAS_LEDS) +#if REST_RES_LEDS + rest_activate_resource(&resource_leds); +#endif +#if REST_RES_TOGGLE + rest_activate_resource(&resource_toggle); +#endif +#endif /* PLATFORM_HAS_LEDS */ +#if defined (PLATFORM_HAS_LIGHT) && REST_RES_LIGHT + SENSORS_ACTIVATE(light_sensor); + rest_activate_resource(&resource_light); +#endif +#if defined (PLATFORM_HAS_BATTERY) && REST_RES_BATTERY + SENSORS_ACTIVATE(battery_sensor); + rest_activate_resource(&resource_battery); +#endif +#if defined (PLATFORM_HAS_RADIO) && REST_RES_RADIO + SENSORS_ACTIVATE(radio_sensor); + rest_activate_resource(&resource_radio); +#endif + + /* Define application-specific events here. */ + etimer_set(&ds_periodic_timer, MESURE_INTERVAL); + while(1) { + PROCESS_WAIT_EVENT(); +#if defined (PLATFORM_HAS_BUTTON) + if (ev == sensors_event && data == &button_sensor) { + PRINTF("BUTTON\n"); +#if REST_RES_EVENT + /* Call the event_handler for this application-specific event. */ + event_event_handler(&resource_event); +#endif +#if REST_RES_SEPARATE && WITH_COAP>3 + /* Also call the separate response example handler. */ + separate_finalize_handler(); +#endif + } +#endif /* PLATFORM_HAS_BUTTON */ + if(etimer_expired(&ds_periodic_timer)) { + PRINTF("Periodic\n"); + etimer_reset(&ds_periodic_timer); +#if REST_RES_DHT11 + out_temp=DHT_Read_Data(DHT_Temp); + humidity=DHT_Read_Data(DHT_RH); +#endif +#if REST_RES_DS1820 + if(ds1820_convert()){ + etimer_set(&ds_read_timer, READ_TIME); + } +#endif + } +#if REST_RES_DS1820 + if(etimer_expired(&ds_read_timer)) { + PRINTF("DS1820_Read\n"); + ds1820_read(); + } +#endif + } /* while (1) */ + + PROCESS_END(); +} diff --git a/examples/osd/er-rest-example-dht11/er-plugtest-server.c b/examples/osd/er-rest-example-dht11/er-plugtest-server.c new file mode 100644 index 000000000..051b44be0 --- /dev/null +++ b/examples/osd/er-rest-example-dht11/er-plugtest-server.c @@ -0,0 +1,561 @@ +/* + * Copyright (c) 2011, Matthias Kovatsch and other contributors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Server for the ETSI IoT CoAP Plugtests, Paris, France, 24 - 25 March 2012 + * \author + * Matthias Kovatsch + */ + +#include +#include +#include +#include "contiki.h" +#include "contiki-net.h" + +#define MAX_PLUGFEST_PAYLOAD 64+1 /* +1 for the terminating zero, which is not transmitted */ + +/* Define which resources to include to meet memory constraints. */ +#define REST_RES_TEST 1 +#define REST_RES_LONG 1 +#define REST_RES_QUERY 1 +#define REST_RES_SEPARATE 1 +#define REST_RES_LARGE 1 +#define REST_RES_LARGE_UPDATE 1 +#define REST_RES_LARGE_CREATE 1 +#define REST_RES_OBS 1 + + +#if !defined (CONTIKI_TARGET_MINIMAL_NET) +#warning "Should only be compiled for minimal-net!" +#endif + + +#if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) && !defined (CONTIKI_TARGET_NATIVE) +#warning "Compiling with static routing!" +#include "static-routing.h" +#endif + +#include "erbium.h" + +/* For CoAP-specific example: not required for normal RESTful Web service. */ +#if WITH_COAP==7 +#include "er-coap-07.h" +#else +#error "Plugtests server without CoAP" +#endif /* CoAP-specific example */ + +#define DEBUG 1 +#if DEBUG +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF("[%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]", ((uint8_t *)addr)[0], ((uint8_t *)addr)[1], ((uint8_t *)addr)[2], ((uint8_t *)addr)[3], ((uint8_t *)addr)[4], ((uint8_t *)addr)[5], ((uint8_t *)addr)[6], ((uint8_t *)addr)[7], ((uint8_t *)addr)[8], ((uint8_t *)addr)[9], ((uint8_t *)addr)[10], ((uint8_t *)addr)[11], ((uint8_t *)addr)[12], ((uint8_t *)addr)[13], ((uint8_t *)addr)[14], ((uint8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF("[%02x:%02x:%02x:%02x:%02x:%02x]",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + + +#if REST_RES_TEST +/* + * Default test resource + */ +RESOURCE(test, METHOD_GET|METHOD_POST|METHOD_PUT|METHOD_DELETE, "test", "title=\"Default test resource\""); + +void +test_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + coap_packet_t *const coap_req = (coap_packet_t *) request; + + uint8_t method = REST.get_method_type(request); + + PRINTF("/test "); + if (method & METHOD_GET) + { + PRINTF("GET "); + /* Code 2.05 CONTENT is default. */ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + REST.set_response_payload(response, buffer, snprintf((char *)buffer, MAX_PLUGFEST_PAYLOAD, "Type: %u\nCode: %u\nMID: %u", coap_req->type, coap_req->code, coap_req->mid)); + } + else if (method & METHOD_POST) + { + PRINTF("POST "); + REST.set_response_status(response, REST.status.CREATED); + REST.set_header_location(response, "/nirvana"); + } + else if (method & METHOD_PUT) + { + PRINTF("PUT "); + REST.set_response_status(response, REST.status.CHANGED); + } + else if (method & METHOD_DELETE) + { + PRINTF("DELETE "); + REST.set_response_status(response, REST.status.DELETED); + } + + PRINTF("(%s %u)\n", coap_req->type==COAP_TYPE_CON?"CON":"NON", coap_req->mid); +} +#endif + +#if REST_RES_LONG +/* + * Long path resource + */ +RESOURCE(longpath, METHOD_GET, "seg1/seg2/seg3", "title=\"Long path resource\""); + +void +longpath_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + coap_packet_t *const coap_req = (coap_packet_t *) request; + + uint8_t method = REST.get_method_type(request); + + PRINTF("/seg1/seg2/seg3 "); + if (method & METHOD_GET) + { + PRINTF("GET "); + /* Code 2.05 CONTENT is default. */ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + REST.set_response_payload(response, buffer, snprintf((char *)buffer, MAX_PLUGFEST_PAYLOAD, "Type: %u\nCode: %u\nMID: %u", coap_req->type, coap_req->code, coap_req->mid)); + } + PRINTF("(%s %u)\n", coap_req->type==COAP_TYPE_CON?"CON":"NON", coap_req->mid); +} +#endif + +#if REST_RES_QUERY +/* + * Resource accepting query parameters + */ +RESOURCE(query, METHOD_GET, "query", "title=\"Resource accepting query parameters\""); + +void +query_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + coap_packet_t *const coap_req = (coap_packet_t *) request; + int len = 0; + const char *query = NULL; + + PRINTF("/query GET (%s %u)\n", coap_req->type==COAP_TYPE_CON?"CON":"NON", coap_req->mid); + + if ((len = REST.get_query(request, &query))) + { + PRINTF("Query: %.*s\n", len, query); + } + + /* Code 2.05 CONTENT is default. */ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + REST.set_response_payload(response, buffer, snprintf((char *)buffer, MAX_PLUGFEST_PAYLOAD, "Type: %u\nCode: %u\nMID: %u\nQuery: %.*s", coap_req->type, coap_req->code, coap_req->mid, len, query)); +} +#endif + +#if REST_RES_SEPARATE +/* Required to manually (=not by the engine) handle the response transaction. */ +#include "er-coap-07-separate.h" +#include "er-coap-07-transactions.h" +/* + * Resource which cannot be served immediately and which cannot be acknowledged in a piggy-backed way + */ +PERIODIC_RESOURCE(separate, METHOD_GET, "separate", "title=\"Resource which cannot be served immediately and which cannot be acknowledged in a piggy-backed way\"", 3*CLOCK_SECOND); + +/* A structure to store the required information */ +typedef struct application_separate_store { + /* Provided by Erbium to store generic request information such as remote address and token. */ + coap_separate_t request_metadata; + /* Add fields for addition information to be stored for finalizing, e.g.: */ + char buffer[MAX_PLUGFEST_PAYLOAD]; +} application_separate_store_t; + +static uint8_t separate_active = 0; +static application_separate_store_t separate_store[1]; + +void +separate_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + coap_packet_t *const coap_req = (coap_packet_t *) request; + + PRINTF("/separate "); + if (separate_active) + { + PRINTF("REJECTED "); + coap_separate_reject(); + } + else + { + PRINTF("STORED "); + separate_active = 1; + + /* Take over and skip response by engine. */ + coap_separate_accept(request, &separate_store->request_metadata); + /* Be aware to respect the Block2 option, which is also stored in the coap_separate_t. */ + + snprintf(separate_store->buffer, MAX_PLUGFEST_PAYLOAD, "Type: %u\nCode: %u\nMID: %u", coap_req->type, coap_req->code, coap_req->mid); + } + + PRINTF("(%s %u)\n", coap_req->type==COAP_TYPE_CON?"CON":"NON", coap_req->mid); +} + +void +separate_periodic_handler(resource_t *resource) +{ + if (separate_active) + { + PRINTF("/separate "); + coap_transaction_t *transaction = NULL; + if ( (transaction = coap_new_transaction(separate_store->request_metadata.mid, &separate_store->request_metadata.addr, separate_store->request_metadata.port)) ) + { + PRINTF("RESPONSE (%s %u)\n", separate_store->request_metadata.type==COAP_TYPE_CON?"CON":"NON", separate_store->request_metadata.mid); + + coap_packet_t response[1]; /* This way the packet can be treated as pointer as usual. */ + + /* Restore the request information for the response. */ + coap_separate_resume(response, &separate_store->request_metadata, CONTENT_2_05); + + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + coap_set_payload(response, separate_store->buffer, strlen(separate_store->buffer)); + + /* + * Be aware to respect the Block2 option, which is also stored in the coap_separate_t. + * As it is a critical option, this example resource pretends to handle it for compliance. + */ + coap_set_header_block2(response, separate_store->request_metadata.block2_num, 0, separate_store->request_metadata.block2_size); + + /* Warning: No check for serialization error. */ + transaction->packet_len = coap_serialize_message(response, transaction->packet); + coap_send_transaction(transaction); + /* The engine will clear the transaction (right after send for NON, after acked for CON). */ + + separate_active = 0; + } else { + PRINTF("ERROR (transaction)\n"); + } + } /* if (separate_active) */ +} +#endif + +#if REST_RES_LARGE +/* + * Large resource + */ +RESOURCE(large, METHOD_GET, "large", "title=\"Large resource\";rt=\"block\""); + +#define CHUNKS_TOTAL 1280 + +void +large_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + int32_t strpos = 0; + + /* Check the offset for boundaries of the resource data. */ + if (*offset>=CHUNKS_TOTAL) + { + REST.set_response_status(response, REST.status.BAD_OPTION); + /* A block error message should not exceed the minimum block size (16). */ + + const char *error_msg = "BlockOutOfScope"; + REST.set_response_payload(response, error_msg, strlen(error_msg)); + return; + } + + /* Generate data until reaching CHUNKS_TOTAL. */ + while (strpos preferred_size) + { + strpos = preferred_size; + } + + /* Truncate if above CHUNKS_TOTAL bytes. */ + if (*offset+(int32_t)strpos > CHUNKS_TOTAL) + { + strpos = CHUNKS_TOTAL - *offset; + } + + REST.set_response_payload(response, buffer, strpos); + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + + /* IMPORTANT for chunk-wise resources: Signal chunk awareness to REST engine. */ + *offset += strpos; + + /* Signal end of resource representation. */ + if (*offset>=CHUNKS_TOTAL) + { + *offset = -1; + } +} +#endif + +#if REST_RES_LARGE_UPDATE +/* + * Large resource that can be updated using PUT method + */ +RESOURCE(large_update, METHOD_GET|METHOD_PUT, "large-update", "title=\"Large resource that can be updated using PUT method\";rt=\"block\""); + +static int32_t large_update_size = 1280; +static uint8_t large_update_store[2048] = {0}; +static unsigned int large_update_ct = -1; + +void +large_update_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + coap_packet_t *const coap_req = (coap_packet_t *) request; + uint8_t method = REST.get_method_type(request); + + if (method & METHOD_GET) + { + /* Check the offset for boundaries of the resource data. */ + if (*offset>=large_update_size) + { + REST.set_response_status(response, REST.status.BAD_OPTION); + /* A block error message should not exceed the minimum block size (16). */ + + const char *error_msg = "BlockOutOfScope"; + REST.set_response_payload(response, error_msg, strlen(error_msg)); + return; + } + + REST.set_response_payload(response, large_update_store+*offset, preferred_size); + REST.set_header_content_type(response, large_update_ct); + + /* IMPORTANT for chunk-wise resources: Signal chunk awareness to REST engine. */ + *offset += preferred_size; + + /* Signal end of resource representation. */ + if (*offset>=large_update_size) + { + *offset = -1; + } + } else { + uint8_t *incoming = NULL; + size_t len = 0; + + unsigned int ct = REST.get_header_content_type(request); + if (ct==-1) + { + REST.set_response_status(response, REST.status.BAD_REQUEST); + const char *error_msg = "NoContentType"; + REST.set_response_payload(response, error_msg, strlen(error_msg)); + return; + } + + if ((len = REST.get_request_payload(request, &incoming))) + { + if (coap_req->block1_num*coap_req->block1_size+len <= sizeof(large_update_store)) + { + memcpy(large_update_store+coap_req->block1_num*coap_req->block1_size, incoming, len); + large_update_size = coap_req->block1_num*coap_req->block1_size+len; + large_update_ct = REST.get_header_content_type(request); + + REST.set_response_status(response, REST.status.CHANGED); + coap_set_header_block1(response, coap_req->block1_num, 0, coap_req->block1_size); + } + else + { + REST.set_response_status(response, REST.status.REQUEST_ENTITY_TOO_LARGE); + REST.set_response_payload(response, buffer, snprintf((char *)buffer, MAX_PLUGFEST_PAYLOAD, "%uB max.", sizeof(large_update_store))); + return; + } + } + else + { + REST.set_response_status(response, REST.status.BAD_REQUEST); + const char *error_msg = "NoPayload"; + REST.set_response_payload(response, error_msg, strlen(error_msg)); + return; + } + } +} +#endif + +#if REST_RES_LARGE_CREATE +/* + * Large resource that can be created using POST method + */ +RESOURCE(large_create, METHOD_POST, "large-create", "title=\"Large resource that can be created using POST method\";rt=\"block\""); + +void +large_create_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + coap_packet_t *const coap_req = (coap_packet_t *) request; + + uint8_t *incoming = NULL; + size_t len = 0; + + unsigned int ct = REST.get_header_content_type(request); + if (ct==-1) + { + REST.set_response_status(response, REST.status.BAD_REQUEST); + const char *error_msg = "NoContentType"; + REST.set_response_payload(response, error_msg, strlen(error_msg)); + return; + } + + if ((len = REST.get_request_payload(request, &incoming))) + { + if (coap_req->block1_num*coap_req->block1_size+len <= 2048) + { + REST.set_response_status(response, REST.status.CREATED); + REST.set_header_location(response, "/nirvana"); + coap_set_header_block1(response, coap_req->block1_num, 0, coap_req->block1_size); + } + else + { + REST.set_response_status(response, REST.status.REQUEST_ENTITY_TOO_LARGE); + const char *error_msg = "2048B max."; + REST.set_response_payload(response, error_msg, strlen(error_msg)); + return; + } + } + else + { + REST.set_response_status(response, REST.status.BAD_REQUEST); + const char *error_msg = "NoPayload"; + REST.set_response_payload(response, error_msg, strlen(error_msg)); + return; + } +} +#endif + +#if REST_RES_OBS +/* + * Observable resource which changes every 5 seconds + */ +PERIODIC_RESOURCE(obs, METHOD_GET, "obs", "title=\"Observable resource which changes every 5 seconds\";obs;rt=\"observe\"", 5*CLOCK_SECOND); + +static uint16_t obs_counter = 0; +static char obs_content[16]; + +void +obs_handler(void* request, void* response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + REST.set_header_max_age(response, 5); + + REST.set_response_payload(response, obs_content, snprintf(obs_content, MAX_PLUGFEST_PAYLOAD, "TICK %lu", obs_counter)); + + /* A post_handler that handles subscriptions will be called for periodic resources by the REST framework. */ +} + +/* + * Additionally, a handler function named [resource name]_handler must be implemented for each PERIODIC_RESOURCE. + * It will be called by the REST manager process with the defined period. + */ +void +obs_periodic_handler(resource_t *r) +{ + ++obs_counter; + + PRINTF("TICK %u for /%s\n", obs_counter, r->url); + + /* Build notification. */ + /*TODO: REST.new_response() */ + coap_packet_t notification[1]; /* This way the packet can be treated as pointer as usual. */ + coap_init_message(notification, COAP_TYPE_NON, CONTENT_2_05, 0 ); + + /* Better use a generator function for both handlers that only takes *resonse. */ + obs_handler(NULL, notification, NULL, 0, NULL); + + /* Notify the registered observers with the given message type, observe option, and payload. */ + REST.notify_subscribers(r, obs_counter, notification); +} +#endif + +PROCESS(plugtest_server, "PlugtestServer"); +AUTOSTART_PROCESSES(&plugtest_server); + +PROCESS_THREAD(plugtest_server, ev, data) +{ + PROCESS_BEGIN(); + + PRINTF("ETSI IoT CoAP Plugtests Server\n"); + +#ifdef RF_CHANNEL + PRINTF("RF channel: %u\n", RF_CHANNEL); +#endif +#ifdef IEEE802154_PANID + PRINTF("PAN ID: 0x%04X\n", IEEE802154_PANID); +#endif + + PRINTF("uIP buffer: %u\n", UIP_BUFSIZE); + PRINTF("LL header: %u\n", UIP_LLH_LEN); + PRINTF("IP+UDP header: %u\n", UIP_IPUDPH_LEN); + PRINTF("REST max chunk: %u\n", REST_MAX_CHUNK_SIZE); + +/* if static routes are used rather than RPL */ +#if !UIP_CONF_IPV6_RPL && !defined (CONTIKI_TARGET_MINIMAL_NET) + set_global_address(); + configure_routing(); +#endif + + /* Initialize the REST engine. */ + rest_init_engine(); + + /* Activate the application-specific resources. */ +#if REST_RES_TEST + rest_activate_resource(&resource_test); +#endif +#if REST_RES_LONG + rest_activate_resource(&resource_longpath); +#endif +#if REST_RES_QUERY + rest_activate_resource(&resource_query); +#endif +#if REST_RES_SEPARATE + rest_activate_periodic_resource(&periodic_resource_separate); +#endif +#if REST_RES_LARGE + rest_activate_resource(&resource_large); +#endif +#if REST_RES_LARGE_UPDATE + large_update_ct = REST.type.APPLICATION_OCTET_STREAM; + rest_activate_resource(&resource_large_update); +#endif +#if REST_RES_LARGE_CREATE + rest_activate_resource(&resource_large_create); +#endif +#if REST_RES_OBS + rest_activate_periodic_resource(&periodic_resource_obs); +#endif + + /* Define application-specific events here. */ + while(1) { + PROCESS_WAIT_EVENT(); + + } /* while (1) */ + + PROCESS_END(); +} diff --git a/examples/osd/er-rest-example-dht11/project-conf.h b/examples/osd/er-rest-example-dht11/project-conf.h new file mode 100644 index 000000000..1c3dd8933 --- /dev/null +++ b/examples/osd/er-rest-example-dht11/project-conf.h @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2010, Swedish Institute of Computer Science. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * + */ + +#ifndef __PROJECT_RPL_WEB_CONF_H__ +#define __PROJECT_RPL_WEB_CONF_H__ + +#define SICSLOWPAN_CONF_FRAG 1 + +/* Disabling RDC for demo purposes. Core updates often require more memory. */ +/* For projects, optimize memory and enable RDC again. */ +//#undef NETSTACK_CONF_RDC +//#define NETSTACK_CONF_RDC nullrdc_driver + +/* Save some memory for the sky platform. */ +#undef UIP_CONF_DS6_NBR_NBU +#define UIP_CONF_DS6_NBR_NBU 10 +#undef UIP_CONF_DS6_ROUTE_NBU +#define UIP_CONF_DS6_ROUTE_NBU 10 + +/* Increase rpl-border-router IP-buffer when using 128. */ +#ifndef REST_MAX_CHUNK_SIZE +#define REST_MAX_CHUNK_SIZE 64 +#endif + +/* Multiplies with chunk size, be aware of memory constraints. */ +#ifndef COAP_MAX_OPEN_TRANSACTIONS +#define COAP_MAX_OPEN_TRANSACTIONS 2 +#endif + +/* Must be <= open transaction number. */ +#ifndef COAP_MAX_OBSERVERS +#define COAP_MAX_OBSERVERS COAP_MAX_OPEN_TRANSACTIONS-1 +#endif + +/* Reduce 802.15.4 frame queue to save RAM. */ +#undef QUEUEBUF_CONF_NUM +#define QUEUEBUF_CONF_NUM 4 + +#endif /* __PROJECT_RPL_WEB_CONF_H__ */ diff --git a/examples/osd/er-rest-example-dht11/run.sh b/examples/osd/er-rest-example-dht11/run.sh new file mode 100755 index 000000000..02b03a5bb --- /dev/null +++ b/examples/osd/er-rest-example-dht11/run.sh @@ -0,0 +1,7 @@ +#!/bin/bash +make clean TARGET=osd-er-lp24 +make TARGET=osd-er-lp24 +avr-size -C --mcu=MCU=atmega128rfa1 er-example-server.osd-er-lp24 +avr-objcopy -j .text -j .data -O ihex er-example-server.osd-er-lp24 er-example-server.osd-er-lp24.hex +avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 -O ihex er-example-server.osd-er-lp24 er-example-server.osd-er-lp24.eep + diff --git a/examples/osd/er-rest-example-dht11/server-client.csc b/examples/osd/er-rest-example-dht11/server-client.csc new file mode 100644 index 000000000..8c45fdf02 --- /dev/null +++ b/examples/osd/er-rest-example-dht11/server-client.csc @@ -0,0 +1,227 @@ + + + [CONTIKI_DIR]/tools/cooja/apps/mrm + [CONTIKI_DIR]/tools/cooja/apps/mspsim + [CONTIKI_DIR]/tools/cooja/apps/avrora + [CONTIKI_DIR]/tools/cooja/apps/serial_socket + [CONTIKI_DIR]/tools/cooja/apps/collect-view + + REST with RPL router + -2147483648 + 123456 + 1000000 + + se.sics.cooja.radiomediums.UDGM + 50.0 + 50.0 + 1.0 + 1.0 + + + 40000 + + + se.sics.cooja.mspmote.SkyMoteType + rplroot + Sky RPL Root + [CONTIKI_DIR]/examples/ipv6/rpl-border-router/border-router.c + make border-router.sky TARGET=sky + [CONTIKI_DIR]/examples/ipv6/rpl-border-router/border-router.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + se.sics.cooja.mspmote.SkyMoteType + server + Erbium Server + [CONTIKI_DIR]/examples/er-rest-example/er-example-server.c + make er-example-server.sky TARGET=sky + [CONTIKI_DIR]/examples/er-rest-example/er-example-server.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + se.sics.cooja.mspmote.SkyMoteType + client + Erbium Client + [CONTIKI_DIR]/examples/er-rest-example/er-example-client.c + make er-example-client.sky TARGET=sky + [CONTIKI_DIR]/examples/er-rest-example/er-example-client.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + + + se.sics.cooja.interfaces.Position + 33.260163187353555 + 30.643217359962595 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 1 + + rplroot + + + + + se.sics.cooja.interfaces.Position + 46.57186415376375 + 40.35946215910942 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 2 + + server + + + + + se.sics.cooja.interfaces.Position + 18.638049428485125 + 47.55034515769599 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 3 + + client + + + + se.sics.cooja.plugins.SimControl + 259 + 0 + 179 + 0 + 0 + + + se.sics.cooja.plugins.Visualizer + + se.sics.cooja.plugins.skins.IDVisualizerSkin + se.sics.cooja.plugins.skins.UDGMVisualizerSkin + se.sics.cooja.plugins.skins.MoteTypeVisualizerSkin + se.sics.cooja.plugins.skins.AttributeVisualizerSkin + se.sics.cooja.plugins.skins.LEDVisualizerSkin + se.sics.cooja.plugins.skins.AddressVisualizerSkin + 3.61568947862321 0.0 0.0 3.61568947862321 15.610600779367 -85.92728269158351 + + 300 + 2 + 178 + 261 + 1 + + + se.sics.cooja.plugins.LogListener + + + + + 762 + 3 + 491 + 2 + 182 + + + se.sics.cooja.plugins.RadioLogger + + 150 + + + 451 + -1 + 305 + 73 + 140 + true + + + SerialSocketServer + 0 + 422 + 4 + 74 + 578 + 18 + + + se.sics.cooja.plugins.TimeLine + + 0 + 1 + 2 + + + + + 125 + 25.49079397896416 + + 1624 + 5 + 252 + 6 + 712 + + + se.sics.cooja.plugins.MoteInterfaceViewer + 2 + + Serial port + 0,0 + + 853 + 1 + 491 + 765 + 182 + + + diff --git a/examples/osd/er-rest-example-dht11/server-only.csc b/examples/osd/er-rest-example-dht11/server-only.csc new file mode 100644 index 000000000..d5eee34d6 --- /dev/null +++ b/examples/osd/er-rest-example-dht11/server-only.csc @@ -0,0 +1,189 @@ + + + [CONTIKI_DIR]/tools/cooja/apps/mrm + [CONTIKI_DIR]/tools/cooja/apps/mspsim + [CONTIKI_DIR]/tools/cooja/apps/avrora + [CONTIKI_DIR]/tools/cooja/apps/serial_socket + [CONTIKI_DIR]/tools/cooja/apps/collect-view + + REST with RPL router + -2147483648 + 123456 + 1000000 + + se.sics.cooja.radiomediums.UDGM + 50.0 + 50.0 + 1.0 + 1.0 + + + 40000 + + + se.sics.cooja.mspmote.SkyMoteType + rplroot + Sky RPL Root + [CONTIKI_DIR]/examples/ipv6/rpl-border-router/border-router.c + make border-router.sky TARGET=sky + [CONTIKI_DIR]/examples/ipv6/rpl-border-router/border-router.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + se.sics.cooja.mspmote.SkyMoteType + server + Erbium Server + [CONTIKI_DIR]/examples/er-rest-example/er-example-server.c + make er-example-server.sky TARGET=sky + [CONTIKI_DIR]/examples/er-rest-example/er-example-server.sky + se.sics.cooja.interfaces.Position + se.sics.cooja.interfaces.RimeAddress + se.sics.cooja.interfaces.IPAddress + se.sics.cooja.interfaces.Mote2MoteRelations + se.sics.cooja.interfaces.MoteAttributes + se.sics.cooja.mspmote.interfaces.MspClock + se.sics.cooja.mspmote.interfaces.MspMoteID + se.sics.cooja.mspmote.interfaces.SkyButton + se.sics.cooja.mspmote.interfaces.SkyFlash + se.sics.cooja.mspmote.interfaces.SkyCoffeeFilesystem + se.sics.cooja.mspmote.interfaces.SkyByteRadio + se.sics.cooja.mspmote.interfaces.MspSerial + se.sics.cooja.mspmote.interfaces.SkyLED + se.sics.cooja.mspmote.interfaces.MspDebugOutput + se.sics.cooja.mspmote.interfaces.SkyTemperature + + + + + se.sics.cooja.interfaces.Position + 33.260163187353555 + 30.643217359962595 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 1 + + rplroot + + + + + se.sics.cooja.interfaces.Position + 35.100895239785295 + 39.70574552287428 + 0.0 + + + se.sics.cooja.mspmote.interfaces.MspMoteID + 2 + + server + + + + se.sics.cooja.plugins.SimControl + 259 + 5 + 179 + 0 + 0 + + + se.sics.cooja.plugins.Visualizer + + se.sics.cooja.plugins.skins.IDVisualizerSkin + se.sics.cooja.plugins.skins.UDGMVisualizerSkin + se.sics.cooja.plugins.skins.MoteTypeVisualizerSkin + se.sics.cooja.plugins.skins.AttributeVisualizerSkin + se.sics.cooja.plugins.skins.LEDVisualizerSkin + se.sics.cooja.plugins.skins.AddressVisualizerSkin + 7.9849281638410705 0.0 0.0 7.9849281638410705 -133.27812697619663 -225.04752569190535 + + 300 + 4 + 175 + 263 + 3 + + + se.sics.cooja.plugins.LogListener + + + + + 560 + 1 + 326 + 1 + 293 + + + se.sics.cooja.plugins.RadioLogger + + 150 + + + 451 + -1 + 305 + 73 + 140 + true + + + SerialSocketServer + 0 + 422 + 2 + 74 + 39 + 199 + + + se.sics.cooja.plugins.TimeLine + + 0 + 1 + + + + + 125 + 25.49079397896416 + + 1624 + 3 + 252 + 4 + 622 + + + se.sics.cooja.plugins.MoteInterfaceViewer + 1 + + Serial port + 0,0 + + 702 + 0 + 646 + 564 + 2 + + + diff --git a/examples/osd/er-rest-example-dht11/static-routing.c b/examples/osd/er-rest-example-dht11/static-routing.c new file mode 100644 index 000000000..628594892 --- /dev/null +++ b/examples/osd/er-rest-example-dht11/static-routing.c @@ -0,0 +1,155 @@ +/* + * static-routing.c + * + * Created on: Oct 12, 2010 + * Author: simonduq + */ + +#include +#include "static-routing.h" + +#define DEBUG 0 +#if DEBUG +#include +#define PRINTF(...) printf(__VA_ARGS__) +#define PRINT6ADDR(addr) PRINTF(" %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x ", ((uint8_t *)addr)[0], ((uint8_t *)addr)[1], ((uint8_t *)addr)[2], ((uint8_t *)addr)[3], ((uint8_t *)addr)[4], ((uint8_t *)addr)[5], ((uint8_t *)addr)[6], ((uint8_t *)addr)[7], ((uint8_t *)addr)[8], ((uint8_t *)addr)[9], ((uint8_t *)addr)[10], ((uint8_t *)addr)[11], ((uint8_t *)addr)[12], ((uint8_t *)addr)[13], ((uint8_t *)addr)[14], ((uint8_t *)addr)[15]) +#define PRINTLLADDR(lladdr) PRINTF(" %02x:%02x:%02x:%02x:%02x:%02x ",(lladdr)->addr[0], (lladdr)->addr[1], (lladdr)->addr[2], (lladdr)->addr[3],(lladdr)->addr[4], (lladdr)->addr[5]) +#else +#define PRINTF(...) +#define PRINT6ADDR(addr) +#define PRINTLLADDR(addr) +#endif + +#include "contiki-net.h" +#include "node-id.h" + +int node_rank; + +struct id_to_addrs { + int id; + uint32_t addr; +}; + +const struct id_to_addrs motes_addrs[] = { +/* + * Static routing requires a map nodeid => address. + * The nodeid can be programmed with the sky-shell. + * The addresses should also be added to /etc/hosts. + * + * aaaa::212:7400:1160:f62d sky1 + * aaaa::212:7400:0da0:d748 sky2 + * aaaa::212:7400:116e:c325 sky3 + * aaaa::212:7400:116e:c444 sky4 + * aaaa::212:7400:115e:b717 sky5 + * + * Add the nodeid and last 4 bytes of the address to the map. + */ + {1, 0x1160f62d}, + {2, 0x0da0d748}, + {3, 0x116ec325}, + {4, 0x116ec444}, + {5, 0x115eb717}, +}; +/* Define the size of the map. */ +#define NODES_IN_MAP 5 + +uint32_t get_mote_suffix(int rank) { + if(--rank >=0 && rank<(sizeof(motes_addrs)/sizeof(struct id_to_addrs))) { + return motes_addrs[rank].addr; + } + return 0; +} + +int get_mote_id(uint32_t suffix) { +#if IN_COOJA + return suffix & 0xff; +#else + int i; + for(i=0; i<(sizeof(motes_addrs)/sizeof(struct id_to_addrs)); i++) { + if(suffix == motes_addrs[i].addr) { + return motes_addrs[i].id; + } + } + return 0; +#endif +} + +void set_global_address(void) { + uip_ipaddr_t ipaddr; + + uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0); + uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr); + uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); +} + +static void add_route_ext(int dest, int next) { + PRINTF("add route ext %d %d\n", dest, next); + uip_ipaddr_t ipaddr_dest, ipaddr_next; + uip_ip6addr(&ipaddr_dest, 0xaaaa, 0, 0, 0, 0, 0, 0, dest); +#if IN_COOJA + uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400 | next, next, next<<8 | next); +#else + uint32_t next_suffix = get_mote_suffix(next); + uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400, (next_suffix >> 16) & 0xffff, next_suffix & 0xffff); +#endif + uip_ds6_route_add(&ipaddr_dest, 128, &ipaddr_next, 0); +} + +void add_route(int dest, int next) { + PRINTF("add route %d %d\n", dest, next); + uip_ipaddr_t ipaddr_dest, ipaddr_next; +#if IN_COOJA + uip_ip6addr(&ipaddr_dest, 0xaaaa, 0, 0, 0, 0x0212, 0x7400 | dest, dest, dest<<8 | dest); + uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400 | next, next, next<<8 | next); +#else + uint32_t dest_suffix = get_mote_suffix(dest); + uint32_t next_suffix = get_mote_suffix(next); + uip_ip6addr(&ipaddr_dest, 0xaaaa, 0, 0, 0, 0x0212, 0x7400, (dest_suffix >> 16) & 0xffff, dest_suffix & 0xffff); + uip_ip6addr(&ipaddr_next, 0xfe80, 0, 0, 0, 0x0212, 0x7400, (next_suffix >> 16) & 0xffff, next_suffix & 0xffff); +#endif + uip_ds6_route_add(&ipaddr_dest, 128, &ipaddr_next, 0); +} + +void configure_routing(void) { + int i; +#if IN_COOJA + node_rank = node_id; +#else + node_rank = -1; + for(i=0; i<(sizeof(motes_addrs)/sizeof(struct id_to_addrs)); ++i) { + if(node_id == motes_addrs[i].id) { + node_rank = i+1; + break; + } + } + + if(node_rank == -1) { + printf("unable to configure routing, node_id=%d\n", node_id); + return; + } +#endif + + printf("configure_routing, node_id=%d, node_rank %d\n", node_id, node_rank); + + if (node_rank == 1) { /* border router #1 */ + add_route_ext(2, 2); + for(i=2; i<=NODES_IN_MAP; ++i) { + add_route(i, 2); + } + } else if (node_rank < NODES_IN_MAP) { /* other node */ + add_route_ext(1, node_rank-1); + add_route_ext(2, node_rank+1); + for(i=1; i<=NODES_IN_MAP; ++i) { + if(inode_rank) { + add_route(i, node_rank+1); + } + } + } else if (node_rank == NODES_IN_MAP) { /* 2nd border router */ + add_route_ext(1, NODES_IN_MAP-1); + for(i=1; i<=NODES_IN_MAP-1; ++i) { + add_route(i, NODES_IN_MAP-1); + } + } +} diff --git a/examples/osd/er-rest-example-dht11/static-routing.h b/examples/osd/er-rest-example-dht11/static-routing.h new file mode 100644 index 000000000..0dff0b7ba --- /dev/null +++ b/examples/osd/er-rest-example-dht11/static-routing.h @@ -0,0 +1,20 @@ +/* + * static-routing.h + * + * Created on: Oct 12, 2010 + * Author: simonduq + */ + +#ifndef STATICROUTING_H_ +#define STATICROUTING_H_ + +#include "contiki.h" + +extern int node_rank; +extern uint32_t get_mote_suffix(int id); +extern int get_mote_id(uint32_t suffix); +extern void add_route(int dest, int next); +extern void set_global_address(void); +extern void configure_routing(void); + +#endif /* STATICROUTING_H_ */ diff --git a/examples/osd/er-rest-example-toggleboard-ds1820/er-example-server.c b/examples/osd/er-rest-example-toggleboard-ds1820/er-example-server.c index ee2aabb4a..0b36228ad 100644 --- a/examples/osd/er-rest-example-toggleboard-ds1820/er-example-server.c +++ b/examples/osd/er-rest-example-toggleboard-ds1820/er-example-server.c @@ -45,7 +45,7 @@ /* Define which resources to include to meet memory constraints. */ #define REST_RES_INFO 1 -#define REST_RES_DS1820 1 +#define REST_RES_DS1820 0 #define REST_RES_HELLO 0 #define REST_RES_MIRROR 0 /* causes largest code size */ #define REST_RES_CHUNKS 0 diff --git a/platform/osd-er-lp24/Makefile.osd-er-lp24 b/platform/osd-er-lp24/Makefile.osd-er-lp24 index 63580683e..9cb38a782 100644 --- a/platform/osd-er-lp24/Makefile.osd-er-lp24 +++ b/platform/osd-er-lp24/Makefile.osd-er-lp24 @@ -5,6 +5,8 @@ CONTIKI_TARGET_MAIN = ${CONTIKI_CORE}.o CONTIKI_TARGET_SOURCEFILES += contiki-main.c params.c node-id.c #Needed for slip CONTIKI_TARGET_SOURCEFILES += button-sensor.c sensors.c slip_uart0.c slip.c +#Needed for DHT11 humidity sensor +CONTIKI_TARGET_SOURCEFILES += dht11.c CONTIKIAVR=$(CONTIKI)/cpu/avr CONTIKIBOARD=. diff --git a/platform/osd-er-lp24/contiki-conf.h b/platform/osd-er-lp24/contiki-conf.h index 409f02fcf..558e41b24 100644 --- a/platform/osd-er-lp24/contiki-conf.h +++ b/platform/osd-er-lp24/contiki-conf.h @@ -137,7 +137,7 @@ typedef unsigned short uip_stats_t; /* Network setup */ /* TX routine passes the cca/ack result in the return parameter */ #define RDC_CONF_HARDWARE_ACK 1 -/* TX routine does automatic cca and optional backoff */ +/* TX routine does automatic cca and optional backoffs */ #define RDC_CONF_HARDWARE_CSMA 1 /* Allow MCU sleeping between channel checks */ #define RDC_CONF_MCU_SLEEP 1 @@ -182,8 +182,8 @@ typedef unsigned short uip_stats_t; #define UIP_CONF_DHCP_LIGHT 1 -//#if 1 /* No radio cycling */ -#if 0 /* radio cycling */ +#if 1 /* No radio cycling */ +//#if 0 /* radio cycling */ #define NETSTACK_CONF_MAC nullmac_driver #define NETSTACK_CONF_RDC sicslowmac_driver @@ -194,8 +194,10 @@ typedef unsigned short uip_stats_t; #define RF230_CONF_AUTOACK 1 /* Request 802.15.4 ACK on all packets sent (else autoretry). This is primarily for testing. */ #define SICSLOWPAN_CONF_ACK_ALL 0 -/* Number of auto retry attempts 0-15 (0 implies don't use extended TX_ARET_ON mode with CCA) */ -#define RF230_CONF_AUTORETRIES 2 +/* 1 + Number of auto retry attempts 0-15 (0 implies don't use extended TX_ARET_ON mode) */ +#define RF230_CONF_FRAME_RETRIES 2 +/* Number of csma retry attempts 0-5 in extended tx mode (7 does immediate tx with no csma) */ +#define RF230_CONF_CSMA_RETRIES 5 /* Default is one RAM buffer for received packets. More than one may benefit multiple TCP connections or ports */ #define RF230_CONF_RX_BUFFERS 3 #define SICSLOWPAN_CONF_FRAG 1 @@ -251,9 +253,10 @@ typedef unsigned short uip_stats_t; #define RTIMER_CONF_NESTED_INTERRUPTS 1 #define RF230_CONF_AUTOACK 1 /* A 0 here means non-extended mode; 1 means extended mode with no retry, >1 for retrys */ -#define RF230_CONF_AUTORETRIES 1 -/* A 0 here means no cca; 1 means extended mode with cca but no retry, >1 for backoff retrys */ -#define RF230_CONF_CSMARETRIES 1 +/* Contikimac strobes on its own, but hardware retries are faster */ +#define RF230_CONF_FRAME_RETRIES 1 +/* Long csma backoffs will compromise radio cycling; set to 0 for 1 csma */ +#define RF230_CONF_CSMA_RETRIES 0 #define SICSLOWPAN_CONF_FRAG 1 #define SICSLOWPAN_CONF_MAXAGE 3 /* 211 bytes per queue buffer. Contikimac burst mode needs 15 for a 1280 byte MTU */ @@ -264,7 +267,7 @@ typedef unsigned short uip_stats_t; #define UIP_CONF_MAX_CONNECTIONS 2 #define UIP_CONF_MAX_LISTENPORTS 4 #define UIP_CONF_UDP_CONNS 5 -#define UIP_CONF_DS6_NBR_NBU 4 +#define UIP_CONF_DS6_NBR_NBU 20 #define UIP_CONF_DS6_DEFRT_NBU 2 #define UIP_CONF_DS6_PREFIX_NBU 3 #define UIP_CONF_DS6_ROUTE_NBU 4 @@ -275,8 +278,10 @@ typedef unsigned short uip_stats_t; #elif 1 /* cx-mac radio cycling */ /* RF230 does clear-channel assessment in extended mode (autoretries>0) */ -#define RF230_CONF_AUTORETRIES 1 -#if RF230_CONF_AUTORETRIES +/* These values are guesses */ +#define RF230_CONF_FRAME_RETRIES 10 +#define RF230_CONF_CSMA_RETRIES 2 +#if RF230_CONF_CSMA_RETRIES #define NETSTACK_CONF_MAC nullmac_driver #else #define NETSTACK_CONF_MAC csma_driver diff --git a/platform/osd-er-lp24/contiki-main.c b/platform/osd-er-lp24/contiki-main.c index 66c7c1db9..bdc494b80 100644 --- a/platform/osd-er-lp24/contiki-main.c +++ b/platform/osd-er-lp24/contiki-main.c @@ -537,17 +537,22 @@ extern uip_ds6_netif_t uip_ds6_if; } if (j) PRINTF(" "); PRINTF("\nRoutes [%u max]\n",UIP_DS6_ROUTE_NB); - for(i = 0,j=1; i < UIP_DS6_ROUTE_NB; i++) { - if(uip_ds6_routing_table[i].isused) { - ipaddr_add(&uip_ds6_routing_table[i].ipaddr); - PRINTF("/%u (via ", uip_ds6_routing_table[i].length); - ipaddr_add(&uip_ds6_routing_table[i].nexthop); + { + uip_ds6_route_t *r; + PRINTF("\nRoutes [%u max]\n",UIP_DS6_ROUTE_NB); + j = 1; + for(r = uip_ds6_route_list_head(); + r != NULL; + r = list_item_next(r)) { + ipaddr_add(&r->ipaddr); + PRINTF("/%u (via ", r->length); + ipaddr_add(&r->nexthop); // if(uip_ds6_routing_table[i].state.lifetime < 600) { - PRINTF(") %lus\n", uip_ds6_routing_table[i].state.lifetime); - // } else { - // PRINTF(")\n"); - // } - j=0; + PRINTF(") %lus\n", r->state.lifetime); + // } else { + // PRINTF(")\n"); + // } + j = 0; } } if (j) PRINTF(" "); diff --git a/platform/osd-er-lp24/dev/dht11.c b/platform/osd-er-lp24/dev/dht11.c new file mode 100644 index 000000000..270bfe6e2 --- /dev/null +++ b/platform/osd-er-lp24/dev/dht11.c @@ -0,0 +1,119 @@ +/* + DHT-11 Library + (c) Created by Charalampos Andrianakis on 18/12/11. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + */ + +#include +#include "contiki.h" +#include "dht11.h" +#include "led.h" // debug + +#define udelay(u) clock_delay_usec(u) +#define mdelay(u) clock_delay_msec(u) + +uint8_t DHT_Read_Data(uint8_t select){ + + //data[5] is 8byte table where data come from DHT are stored + //laststate holds laststate value + //counter is used to count microSeconds + uint8_t data[5], laststate = 0, counter = 0, j = 0, i = 0; + + //Clear array + data[0] = data[1] = data[2] = data[3] = data[4] = 0; + + uint8_t volatile sreg; + sreg = SREG; /* Save status register before disabling interrupts. */ + cli(); /* Disable interrupts. */ + + //Prepare the bus + PIN_INIT(); + //Set pin Output + //Pin High + DHT_DRIVE(); + mdelay(250); //Wait for 250mS + + //Send Request Signal + //Pin Low + OUTP_0(); + mdelay(20); //20ms Low + + //Pin High + OUTP_1(); + udelay(40); //40us High + + //Set pin Input to read Bus + //Set pin Input + DHT_RELEASE(); + laststate=DHT_INP(); //Read Pin value + + //Repeat for each Transistions + for (i=0; i254) break; + } + + if (counter>254) break; + + //laststate==_BV(DHT_PIN) checks if laststate was High + //ignore the first 2 transitions which are the DHT Response + //if (laststate==_BV(DHT_PIN) && (i > 2)) { + if ((i&0x01) && (i > 2)) { + //Save bits in segments of bytes + //Shift data[] value 1 position left + //Example. 01010100 if we shift it left one time it will be + //10101000 + led1_on(); + + data[j/8]<<=1; + if (counter >= 15) { //If it was high for more than 40uS + led1_off(); + data[j/8]|=1; //it means it is bit '1' so make a logic + led1_on(); + } //OR with the value (save it) + j++; //making an OR by 1 to this value 10101000 + led1_off(); + + } //we will have the resault 10101001 + //1 in 8-bit binary is 00000001 + //j/8 changes table record every 8 bits which means a byte has been saved + //so change to next record. 0/8=0 1/8=0 ... 7/8=0 8/8=1 ... 15/8=1 16/8=2 + laststate=DHT_INP(); //save current state + counter=0; //reset counter + + } + SREG = sreg; /* Enable interrupts. */ + + //Check if data received are correct by checking the CheckSum + if (data[0] + data[1] + data[2] + data[3] == data[4]) { + if (select==DHT_Temp) { //Return the value has been choosen + return(data[2]); + }else if(select==DHT_RH){ + return(data[0]); + } + }else{ +// uart_puts("\r\nCheck Sum Error"); + } + + return 0xff; // Check Sum Error +} diff --git a/platform/osd-er-lp24/dev/dht11.h b/platform/osd-er-lp24/dev/dht11.h new file mode 100644 index 000000000..7012b75c6 --- /dev/null +++ b/platform/osd-er-lp24/dev/dht11.h @@ -0,0 +1,72 @@ +/* + DHT-11 Library + (c) Created by Charalampos Andrianakis on 18/12/11. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + */ + +#include +#include +#include + +/* DHT 1-wire is at PortE.6 */ +#define DHT_PIN_READ PINE +#define DHT_PIN_MASK _BV(PE6) +#define DHT_PxOUT PORTE +#define DHT_PxDIR DDRE + +#define SET_PIN_INPUT() (DHT_PxDIR &= ~DHT_PIN_MASK) +#define SET_PIN_OUTPUT() (DHT_PxDIR |= DHT_PIN_MASK) + +#define OUTP_0() (DHT_PxOUT &= ~DHT_PIN_MASK) +#define OUTP_1() (DHT_PxOUT |= DHT_PIN_MASK) + +#define PIN_INIT() do{ \ + SET_PIN_INPUT(); \ + OUTP_0(); \ + } while(0) + + +/* Drive the one wire interface hight */ +#define DHT_DRIVE() do { \ + SET_PIN_OUTPUT(); \ + OUTP_1(); \ + } while (0) + +/* Release the one wire by turning on the internal pull-up. */ +#define DHT_RELEASE() do { \ + SET_PIN_INPUT(); \ + OUTP_1(); \ + } while (0) + +/* Read one bit. */ +#define DHT_INP() (DHT_PIN_READ & DHT_PIN_MASK) + +//The packet size is 40bit but each bit consists of low and high state +//so 40 x 2 = 80 transitions. Also we have 2 transistions DHT response +//and 2 transitions which indicates End Of Frame. In total 84 +#define MAXTIMINGS 84 + +//Select between Temp and Humidity Read +#define DHT_Temp 0 +#define DHT_RH 1 + +//This is the main function which requests and reads the packet +uint8_t DHT_Read_Data(uint8_t select); + diff --git a/platform/osd-er-lp24/params.h b/platform/osd-er-lp24/params.h index 0b1e7c940..da2f6e3d5 100644 --- a/platform/osd-er-lp24/params.h +++ b/platform/osd-er-lp24/params.h @@ -78,10 +78,10 @@ extern uint8_t eemem_domain_name[30]; /* This form of of EUI64 mac allows full 6LoWPAN header compression from mac address */ #if UIP_CONF_LL_802154 //#define PARAMS_EUI64ADDR {0x02, 0xNN, 0xNN, 0xNN, 0xNN, 0xNN, 0xNN, 0xNN} -#define PARAMS_EUI64ADDR {0x02, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x0b} +#define PARAMS_EUI64ADDR {0x02, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x03} #else //#define PARAMS_EUI64ADDR {0x02, 0xNN, 0xNN, 0xff, 0xfe, 0xNN, 0xNN, 0xNN} -#define PARAMS_EUI64ADDR {0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x0b} +#define PARAMS_EUI64ADDR {0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x03} #endif /* This form of of EUI64 mac allows 16 bit 6LoWPAN header compression on multihops */ //#define PARAMS_EUI64ADDR {0x02, 0x00, 0x00, 0xff, 0xfe, 0x00, 0xNN, 0xNN}